def get_file(self, path_mapa):
"""
Recibe un string con el path de la partida.
Revisa los archivos dentro de mapas/, y maneja posibles sub-directorios
dentro de dicha carpeta.
Es posible que un archivo no posea extensión en algunos sistemas
operativos, por lo que este método no chequea si el input tenga una.
"""
path_mapa = path_mapa.strip()
if "\\" in path_mapa:
msg = "Path debe usar slash '/', no backslash '\\'"
self.feedback_signal.emit(msg)
elif path_mapa == "":
msg = ""
self.feedback_signal.emit(msg)
else:
path_mapa = ["mapas"] + path_mapa.split("/")
try:
with open(os.path.join(*path_mapa)) as archivo_mapa:
lista_mapa = []
for linea in archivo_mapa.read().splitlines():
lista_mapa.append(linea.split(" "))
mapa = Mapa(lista_mapa)
# procesar...
# Agregar error de formato en mapa
self.goto_signal.emit(mapa)
except FileNotFoundError as err:
msg = f"ERROR: {err.filename} no existe."
self.feedback_signal.emit(msg)
def test_init2(self):
alto = 15
largo = 15
mapa = Mapa(alto, largo)
# Me fijo si tiene el alto y largo que le pedí
self.assertEqual(len(mapa.celdas), alto)
for i in range(0, alto - 1):
self.assertEqual(len(mapa.celdas[i]), largo)
# Primera y última fila
for i in (0, (alto - 1)):
for j in range(0, largo):
self.assertEqual(
"Pared_no_rompible"
in str(type(mapa.celdas[i][j].contenido)), True)
# for i in range(2, alto):
# for j in range(2, largo):
# if(i % 2 == 0):
# #Dummy
# self.assertEqual("Contenido_dummy" in str(type(mapa.celdas[i][j].contenido)), True)
# else:
# # Paredes
# if(j % 2 == 0):
# self.assertEqual("Contenido_dummy" in str(type(mapa.celdas[i][j].contenido)), True)
# else:
# self.assertEqual("Pared_no_rompible" in str(type(mapa.celdas[i][j].contenido)), True)
# Primera y última columna
for j in (0, (largo - 1)):
for i in range(0, alto):
self.assertEqual(
"Pared_no_rompible"
in str(type(mapa.celdas[i][j].contenido)), True)
def __init__(self, x, y, angulo, raio):
self.coord_x = x
self.coord_y = y
self.angulo = angulo
self.direcao = Direcoes.LESTE
self.raio = raio
self.vel_motor_direita = 0
self.vel_motor_esquerda = 0
self.dist_esquerda_anterior = 0
self.dist_direita_anterior = 0
self.mapa = Mapa()
self.mapa.inicializa()
self.lista_de_comandos = []
self.algoritmo_de_movimentacao = algoritmo_de_movimentacao
self.algoritmo_de_movimentacao.setup(self)
self.estado = self.Estados.PARA
self.contagem = 0
self.sensores_distancia = []
self.sensores_distancia.append(SensorDistancia(raio, 0,
0)) # sensor frontal
self.sensores_distancia.append(SensorDistancia(0, raio, math.pi /
2)) # sensor esquerdo
self.sensores_distancia.append(SensorDistancia(0, -raio, -math.pi /
2)) # sensor direito
self.retas = []
self.retas.append([-raio, -raio, raio, -raio, None]) # Roda direita
self.retas.append([-raio, raio, raio, raio, None]) # Roda esquerda
self.referencia_figura = None
self.ideal = True
def mapa_aleatorio(ciudades):
m = Mapa()
for x in ciudades:
m.agregar_ciudad(x)
for x in ciudades:
for y in ciudades:
if x<y:
m.agregar_camino(x, y, random.randint(1, 100))
return m
def distanciaAlSol(planeta):
mapa = Mapa()
vectorPlaneta = mapa.obtenerVector(planeta)
if not v1:
print("El planeta no existe")
return False
# Calcular distancia
distancia = 0 # ???
return distancia
def crear_mapa(self, filas):
"""Crea el Mapa a partir de la definicion provista por parametro (`filas`),
y devuelve una tupla con el mapa y el actor que representa al heroe del juego.
`filas` es una lista de strings, que corresponde con el contenido completo
del archivo .map.Se presupone que en el mapa se proporciona una salida para
poder finalizar el juego, y si se proporciona algun caracter que no corresponde
a ningun personaje, se lo reemplaza por una celda vacía automáticamente.
Si hay mas de un heroe en la definicion del mapa, o bien si
no hay ningun heroe, la funcion lanza una excepcion, si el mapa no tiene
el formato correcto(debe ser rectangular), también
"""
dic_funciones = {
"#": Juego.agregar_pared,
"o": Juego.agregar_orco,
"g": Juego.agregar_goblin,
"<": Juego.agregar_salida
}
ALTO = len(filas)
ANCHO = len(filas[0])
if ANCHO == 0: raise IndexError("Linea vacia")
mapa = Mapa(ANCHO, ALTO)
x = 0
y = -1
heroe = None
cantidad_heroes = 0
for fila in filas:
if len(fila) != ANCHO:
raise errores.MapaIncorrectoError(
"la linea", fila,
"no contiene la misma cantidad de caracteres que la primer linea del archivo"
)
x = 0
y += 1
for caracter in fila:
if caracter == "@":
# Lo necesitamos ya que, debemos definir heroe para poder devolverlo
heroe = actores.Heroe()
mapa.agregar_actor(heroe, x, y)
cantidad_heroes += 1
if cantidad_heroes > 1:
raise errores.DemasiadosHeroesError(
"Se esta añadiendo", cantidad_heroes - 1,
"heroes de mas")
elif caracter in dic_funciones:
dic_funciones[caracter](self, mapa, x, y)
x += 1
if heroe == None:
raise errores.NoHayHeroeError("No hay ningun heroe(@) en el mapa")
return mapa, heroe
def generar_laberinto(filas, columnas):
"""Generar un laberinto.
Argumentos:
filas, columnas (int): Tamaño del mapa
Devuelve:
Mapa: un mapa nuevo con celdas bloqueadas formando un laberinto
aleatorio
"""
camino = Pila()
celdas_visitadas = []
mapa = Mapa(filas, columnas)
mapa.bloquear_todo()
camino.apilar(mapa.origen())
celdas_visitadas.append(mapa.origen())
mapa.desbloquear(mapa.origen())
def backtrack(camino, celdas_visitadas, mapa):
celdas_a_elegir = []
celda = camino.ver_tope()
for celda_vecina in mapa.obtener_vecinos_pares(celda):
if not celda_vecina in celdas_visitadas:
if celda_vecina.fila != 0 and celda_vecina.columna != 0:
if celda_vecina.fila != mapa.filas - 1 and celda_vecina.columna != mapa.columnas - 1:
celdas_a_elegir.append(celda_vecina)
if not celdas_a_elegir == [] and mapa.destino() != celda:
indice_aleatorio = random.randint(0, len(celdas_a_elegir) - 1)
celda_aleatoria = celdas_a_elegir[indice_aleatorio]
camino.apilar(celda_aleatoria)
celdas_visitadas.append(celda_aleatoria)
mapa.desbloquear(celda_aleatoria)
celda_intermedia = celda.obtener_celda_intermedia(celda_aleatoria)
mapa.desbloquear(celda_intermedia)
else:
camino.desapilar()
return camino, celdas_visitadas
while not camino.esta_vacia():
camino, celdas_visitadas = backtrack(camino, celdas_visitadas, mapa)
# try:
# camino, celdas_visitadas = backtrack(camino, celdas_visitadas, mapa)
# except:
# raise Exception(f"excepcion al generar laberinto:{camino} {celdas_visitadas}")
mapa.desbloquear(mapa.destino())
return mapa
def inicializarMapa(self):
self.mapa = Mapa(self.estado['linhas'], self.estado['colunas'])
# Temos que adicionar todas as unidades ao mapa, para que ele
# as possa desenhar
self.mapa.inserirUnidade(self.robo)
self.mapa.inserirUnidade(self.meta)
for p in self.estado['pedras']:
self.mapa.inserirUnidade(p)
for p in self.estado['pontos']:
self.mapa.inserirUnidade(p)
# Por final é preciso adicionar o mapa ao cenário do Jogo, para
# que o jogo decidir desenhar o mapa.
self.add(self.mapa)
def main():
os.system('cls')
mapa = Mapa(4, 1, 1, 2)
print(
"------------------------------ START ------------------------------"
)
print(" ---SIMBOLISMO---")
print(" A: AIRE")
print(" S: PRESTE")
print(' H: HOYO')
print(" W: WUMPUS")
print(" G: ORO")
print(" AG: RECORRIDO DEL AGENTE")
print(" SEG: LUGAR SEGURO\n")
mapa.showMap()
bestFirst(mapa)
def main(ekran):
curses.curs_set(0)
ekran.clear()
ekran_y = 40
ekran_x = 100
okno_mapy = curses.newwin(ekran_y, ekran_x-15,0,0)
okno_eq = curses.newwin(ekran_y, ekran_x-60,0,ekran_x-16)
curses.beep()
okno_eq.border(0,0,0,0,curses.ACS_TTEE,0,curses.ACS_BTEE,0)
if (curses.LINES -1 < ekran_y) | (curses.COLS -1 < ekran_x):
return ("Okno terminala jest za male!")
postac = Postac(*okno_mapy.getmaxyx(), okno_mapy)
mapa = Mapa(okno_mapy, postac)
mapa.stworz_pokoj()
while True:
mapa.rysuj()
ekran.refresh()
okno_mapy.refresh()
okno_eq.refresh()
strzalka = ekran.getch()
postac.ruch(strzalka)
ekran.getch()
def __init__(self, superficie, nivel, slot):
from jogador import Jogador
from mapa import Mapa
from poderes import Cinza
from entidades import classes_instanciaveis, renderizar_hitbox, poderes_no_jogador
self.__classes_instanciaveis = classes_instanciaveis
global dicionaro_mapa
super().__init__(superficie)
(width, height) = superficie.get_size()
self.__campo_visivel = pygame.Rect(0, 0, width, height)
self.__comeco = 0
self.__tempo_maximo = 350
self.__fonte = pygame.font.SysFont('miriam', 48)
self.__atrasofim = 0
self.__nivel = nivel
self.__slot = slot
self.__sobreposicao = None
##### ENTRADAS DO JOGADOR #####
self.__cima, self.__baixo, self.__direita, self.__esquerda = 0, 0, 0, 0
self.__espaco = False
self.__bola_fogo = False
self.__troca_poder = False
##### MAPA #####
self.__mapa = Mapa(superficie)
poder_atual = Cinza()
poder_armazenado = Cinza()
slots = DAOJogo.saves
slot_atual = slots[self.__slot]
for item in poderes_no_jogador:
if item.__name__ == slot_atual[2]:
poder_atual = item()
if item.__name__ == slot_atual[3]:
poder_armazenado = item()
self.__jogador = self.__mapa.iniciar(nivel, dicionaro_mapa,
poder_atual, poder_armazenado,
slot_atual[4])
self.__comeco = pygame.time.get_ticks() / 1000
if not pygame.mixer.music.get_busy(): pygame.mixer.music.play(-1)
def __init__(self, superficie, nivel):
self.__superficie = superficie
self.__background_colour = (150, 220, 255) # Cor do fundo
(width, height) = superficie.get_size()
self.__campo_visivel = pygame.Rect(0, 0, width, height)
self.__comeco = 0
self.__tempo_maximo = 350
self.__fonte = pygame.font.SysFont('Arial', 20)
self.__atrasofim = 0
##### ENTRADAS DO JOGADOR #####
self.__cima, self.__baixo, self.__direita, self.__esquerda = 0, 0, 0, 0
self.__atrito = 0.5
self.__espaco = False
self.__bola_fogo = False
###### INSTANCIAS DE OBJETOS ######
self.__jogador = Jogador('mario', 200, 550, 0, 1)
##### MAPA #####
self.__mapa = Mapa((width, height))
self.__mapa.iniciar([nivel[0].copy(), nivel[1].copy()])
self.__comeco = pygame.time.get_ticks() / 1000
# Dada una lista de ciudades, arma un mapa con distancias aleatorias
# entre cada par de ciudades.
def mapa_aleatorio(ciudades):
m = Mapa()
for x in ciudades:
m.agregar_ciudad(x)
for x in ciudades:
for y in ciudades:
if x<y:
m.agregar_camino(x, y, random.randint(1, 100))
return m
#######################################################################
if __name__=="__main__":
mapa1 = Mapa()
mapa1.agregar_ciudad('a')
mapa1.agregar_ciudad('b')
mapa1.agregar_ciudad('c')
mapa1.agregar_ciudad('d')
mapa1.agregar_ciudad('e')
mapa1.agregar_camino('a', 'b', 2)
mapa1.agregar_camino('a', 'c', 5)
mapa1.agregar_camino('a', 'd', 1)
mapa1.agregar_camino('a', 'e', 3)
mapa1.agregar_camino('b', 'c', 1)
mapa1.agregar_camino('b', 'd', 3)
mapa1.agregar_camino('b', 'e', 9)
mapa1.agregar_camino('c', 'd', 1)
mapa1.agregar_camino('c', 'e', 4)
mapa1.agregar_camino('d', 'e', 2)
# lo recordamos.
if di < menor_distancia:
mejor_recorrido = re
menor_distancia = di
# Paso para atrás.
ciudades_faltantes.add(c)
recorrido_actual.pop()
return mejor_recorrido
#######################################################################
if __name__ == "__main__":
mapa1 = Mapa()
mapa1.agregar_ciudad('a')
mapa1.agregar_ciudad('b')
mapa1.agregar_ciudad('c')
mapa1.agregar_ciudad('d')
mapa1.agregar_ciudad('e')
mapa1.agregar_camino('a', 'b', 2)
mapa1.agregar_camino('a', 'c', 5)
mapa1.agregar_camino('a', 'd', 1)
mapa1.agregar_camino('a', 'e', 3)
mapa1.agregar_camino('b', 'c', 1)
mapa1.agregar_camino('b', 'd', 3)
mapa1.agregar_camino('b', 'e', 9)
mapa1.agregar_camino('c', 'd', 1)
mapa1.agregar_camino('c', 'e', 4)
mapa1.agregar_camino('d', 'e', 2)
from robot import Robot
from mapa import Mapa
from moneda import Moneda
from utilidades import cargar_mapa, cargar_instrucciones
import time
mi_mapa = cargar_mapa("mapas/mapa1.txt")
reglas = cargar_instrucciones("instrucciones/programa1.txt")
mapa = Mapa(4, 8)
for y in range(len(mi_mapa)):
fila = mi_mapa[y]
for x in range(len(fila)):
casilla = mi_mapa[y][x]
if casilla == "*":
robot = Robot(x, y)
mapa.asignar_robot(robot)
robot.asignar_mapa(mapa)
else:
cantidad = int(casilla)
for i in range(cantidad):
moneda = Moneda(x, y)
mapa.agregar_moneda(moneda)
mon = 0
for i in reglas:
if i == 'PICK':
robot.recoger()
mon += 1
if i == 'MOVE':
robot.move()
def main():
global FPSCLOCK, POVRSINA
startKliknut = 0
startVrijeme = 1
pygame.mixer.pre_init(44100, 16, 2, 4096)
pygame.init()
FPSCLOCK = pygame.time.Clock()
POVRSINA = pygame.display.set_mode((UkupnaVisina, SirinaProzora), 0, 32)
#zvukovi
pucanjZvuk = pygame.mixer.Sound("glazba/pucanj.ogg")
ouchZvuk = pygame.mixer.Sound("glazba/ouch.ogg")
smrtZvuk = pygame.mixer.Sound("glazba/smrt.ogg")
pygame.mixer.music.load('glazba/menu.ogg')
pygame.mixer.music.play(-1, 0.0)
lvlSeed = maestro()
UI = sucelje(VisinaProzora, SirinaProzora, POVRSINA, menuLvl1, menuLvl2,
menuLvl3, glavniMenu, predjenLabel, toranj_upgrade_hover,
ikonaStart_H)
mousex = 0
mousey = 0
pygame.display.set_caption('Zavrsni')
pygame.mouse.set_visible(False)
odabraniToranj = None
odabraniUpgrade = None
odabraniLvl = None
mod = modMenu
pocetak = 1
listaNeprijatelj = []
izvrsavaj = True
audio = True
while izvrsavaj:
kliknuto = False
for event in pygame.event.get():
if event.type == QUIT or (event.type == KEYUP
and event.key == K_ESCAPE):
izvrsavaj = False
if event.type == MOUSEMOTION:
mousex, mousey = event.pos
if event.type == MOUSEBUTTONUP:
mousex, mousey = event.pos
kliknuto = True
if mod == modMenu:
POVRSINA.blit(naslov, ((0, 0), (840, 480)))
UI.gumbGlavniMenu(menuGumb)
#varijable tornjeva
#Tetejac
dmg1 = 10
domet1 = 100
ASpeed1 = 700
brzinaP1 = 15
cijena1 = 10
cijenau1 = 5
#Kalašnjikov
dmg2 = 15
domet2 = 200
ASpeed2 = 900
brzinaP2 = 15
cijena2 = 20
cijenau2 = 5
#Karabin
dmg3 = 20
domet3 = 200
ASpeed3 = 900
brzinaP3 = 20
cijena3 = 50
cijenau3 = 10
#snajper
dmg4 = 100
domet4 = 500
ASpeed4 = 7000
brzinaP4 = 40
cijena4 = 100
cijenau4 = 30
#mitraljez
dmg5 = 5
domet5 = 90
ASpeed5 = 333
brzinaP5 = 20
cijena5 = 100
cijenau5 = 50
if kliknuto:
UI.klikGlavniMenu(mousex, mousey, menuStisnuto)
odabraniLvl = UI.kliknutoGlavniMenu(mousex, mousey)
if odabraniLvl is not None:
mod = modIgra
lvlSeed.lvlLoad(odabraniLvl)
grid = lvlSeed.grid()
start = lvlSeed.start()
kraj = lvlSeed.kraj()
startGold = lvlSeed.startGold()
brojNeprijatelja = lvlSeed.brNeprijatelja()
zgradaHP = lvlSeed.zgradaHP()
UI.postaviMrezu(grid)
UI.postaviNovce(startGold)
pygame.mixer.music.fadeout(1000)
pygame.mixer.music.load('glazba/' + odabraniLvl + '.ogg')
pygame.mixer.music.play(-1, 0.0)
lvl = Mapa(grid, VisinaProzora, SirinaProzora, okolis,
put_ravno, put_dole, put_kutLD, put_kutDD,
put_kraj, put_kraj_D, put_pocetak_D,
put_pocetak_G)
tornjevi = []
GlZgrada = zgrada(POVRSINA, glavnaZgrada, zgradaHP, kraj,
VisinaProzora, SirinaProzora, grid)
#if not kliknuto:
UI.crtajGlavniMenu()
elif mod == modPobjeda:
UI.gumbPobjeda(menuGumb)
if kliknuto:
if UI.kliknutoPobjeda(mousex, mousey, menuStisnuto):
mod = modMenu
#if not kliknuto:
# UI.hoverPobjeda(mousex, mousey)
UI.CrtajPobjedu()
elif mod == modIzgubljeno:
UI.crtajPreostalo(trenutnoNeprijatelja, ukupnoNeprijatelja)
UI.gumbPobjeda(menuGumb)
if kliknuto:
if UI.kliknutoPobjeda(mousex, mousey, menuStisnuto):
mod = modMenu
#if not kliknuto:
# UI.hoverPobjeda(mousex, mousey)
UI.CrtajIzgubljeno(izgubljenoSlika)
elif mod == modIgra:
UI.menuObrub(menuSlika)
UI.gumbTornja(slikaGumb)
if odabraniToranj is not None:
UI.odabraniGumb(odabraniToranj, slikaOdabrano)
UI.menu(toranj1ikona, toranj2ikona, toranj3ikona, snajperikona, mitraljezikona, \
toranj1_upgrade, toranj2_upgrade, toranj3_upgrade, toranj4_upgrade, toranj5_upgrade, \
dmg1, dmg2, dmg3, dmg4, dmg5, \
domet1, domet2, domet3, domet4, domet5, \
cijena1, cijena2, cijena3, cijena4, cijena5, \
cijenau1, cijenau2, cijenau3, cijenau4, cijenau5, ikonaStart)
if audio:
UI.CrtajAudio(audioON)
else:
UI.CrtajAudio(audioOFF)
dmgLista = []
lvl.crtajMrezu(POVRSINA, start, kraj)
#neprijatelji
if startKliknut:
if startVrijeme:
startVrijeme = 0
lvlSeed.postaviVrijeme()
#stvaranje neprijatelja
elif lvlSeed.vrijeme():
tip, brzina, HP = lvlSeed.vratiNeprijatelj()
if tip is not None:
if tip == 1:
ikona = ikonaNeprijatelj1
dmgIkona = dmgikonaNeprijatelj1
elif tip == 2:
ikona = ikonaNeprijatelj1a
dmgIkona = dmgikonaNeprijatelj1a
elif tip == 3:
ikona = ikonaNeprijatelj2
dmgIkona = dmgikonaNeprijatelj2
elif tip == 4:
ikona = ikonaNeprijatelj2a
dmgIkona = dmgikonaNeprijatelj2a
elif tip == 5:
ikona = ikonaNeprijatelj3
dmgIkona = dmgikonaNeprijatelj3
elif tip == 6:
ikona = ikonaNeprijatelj3a
dmgIkona = dmgikonaNeprijatelj3a
elif tip == 7:
ikona = ikonaNeprijatelj4
dmgIkona = dmgikonaNeprijatelj4
else:
ikona = ikonaNeprijatelj4a
dmgIkona = dmgikonaNeprijatelj4a
listaNeprijatelj.append(
neprijatelj(grid, VisinaProzora, SirinaProzora,
start, kraj, POVRSINA, brzina, R,
ikona, dmgIkona, HP, ouchZvuk))
else:
pocetak = 0
NeprijateljiRect = []
GlZgrada.crtaj()
for i in range(len(listaNeprijatelj)):
listaNeprijatelj[i].Pomakni()
for i in range(len(listaNeprijatelj)):
NeprijateljiRect.append(listaNeprijatelj[i].ikonaRect)
#Gradnja
if kliknuto:
UI.startKliknut(mousex, mousey)
if UI.AudioKliknut(mousex, mousey):
audio = not audio
if not startKliknut:
startKliknut = UI.kliknutoStart(mousex, mousey)
lijevo, gore = UI.poljeNaPixelu(mousex, mousey)
#gradnja upgradea
if lijevo is None and gore is None:
odabraniToranj = UI.odabraniToranj(mousex, mousey,
slikaOdabrano)
odabraniUpgrade = UI.odabraniUpgrade(mousex, mousey)
#postavljanje parametara upgradeova
if odabraniUpgrade is not None:
if odabraniUpgrade == upgrade1:
if UI.vratiNovce() >= cijenau1:
dmg1 = dmg1 + 1
UI.azurirajNovce(-cijenau1)
cijenau1 = cijenau1 + 1
for i in tornjevi:
if i.vratiTip() == 1:
i.upgradeDMG(1)
if odabraniUpgrade == upgrade2:
if UI.vratiNovce() >= cijenau2:
dmg2 = dmg2 + 1
UI.azurirajNovce(-cijenau2)
cijenau2 = cijenau2 + 1
for i in tornjevi:
if i.vratiTip() == 2:
i.upgradeDMG(1)
if odabraniUpgrade == upgrade3:
if UI.vratiNovce() >= cijenau3:
dmg3 = dmg3 + 1
UI.azurirajNovce(-cijenau3)
cijenau3 = cijenau3 + 1
for i in tornjevi:
if i.vratiTip() == 3:
i.upgradeDMG(1)
if odabraniUpgrade == upgrade4:
if UI.vratiNovce() >= cijenau4:
dmg4 = dmg4 + 50
UI.azurirajNovce(-cijenau4)
cijenau4 = cijenau4 + 3
for i in tornjevi:
if i.vratiTip() == 4:
i.upgradeDMG(50)
if odabraniUpgrade == upgrade5:
if UI.vratiNovce() >= cijenau5:
dmg5 = dmg5 + 2
UI.azurirajNovce(-cijenau5)
cijenau5 = cijenau5 + 5
for i in tornjevi:
if i.vratiTip() == 5:
i.upgradeDMG(2)
#gradnja tornja
elif not grid[gore][lijevo] == Z and not grid[gore][
lijevo] == T:
#stvaranje tornjeva
if odabraniToranj is not None:
if odabraniToranj == toranj1:
if UI.vratiNovce() >= cijena1:
grid[gore][lijevo] = T
tornjevi.append(
toranj(1, brzinaP1, gore, lijevo, grid,
POVRSINA, VisinaProzora,
SirinaProzora, domet1, dmg1,
ASpeed1, toranj1slika, pucanjZvuk))
UI.azurirajNovce(-cijena1)
cijena1 = cijena1 + 10
if odabraniToranj == toranj2:
if UI.vratiNovce() >= cijena2:
grid[gore][lijevo] = T
tornjevi.append(
toranj(2, brzinaP2, gore, lijevo, grid,
POVRSINA, VisinaProzora,
SirinaProzora, domet2, dmg2,
ASpeed2, toranj2slika, pucanjZvuk))
UI.azurirajNovce(-cijena2)
cijena2 = cijena2 + 10
if odabraniToranj == toranj3:
if UI.vratiNovce() >= cijena3:
grid[gore][lijevo] = T
tornjevi.append(
toranj(3, brzinaP3, gore, lijevo, grid,
POVRSINA, VisinaProzora,
SirinaProzora, domet3, dmg3,
ASpeed3, toranj3slika, pucanjZvuk))
UI.azurirajNovce(-cijena3)
cijena3 = cijena3 + 10
if odabraniToranj == snajper:
if UI.vratiNovce() >= cijena4:
grid[gore][lijevo] = T
tornjevi.append(
toranj(4, brzinaP4, gore, lijevo, grid,
POVRSINA, VisinaProzora,
SirinaProzora, domet4, dmg4,
ASpeed4, snajperslika, pucanjZvuk))
UI.azurirajNovce(-cijena4)
cijena4 = cijena4 + 20
if odabraniToranj == mitraljez:
if UI.vratiNovce() >= cijena5:
grid[gore][lijevo] = T
tornjevi.append(
toranj(5, brzinaP5, gore, lijevo, grid,
POVRSINA, VisinaProzora,
SirinaProzora, domet5, dmg5,
ASpeed5, mitraljezslika,
pucanjZvuk))
UI.azurirajNovce(-cijena5)
cijena5 = cijena5 + 20
if not kliknuto:
UI.crtajObrub(mousex, mousey)
#Damage
for i in range(len(tornjevi)):
tornjevi[i - 1].Crtaj()
dmgLista.append(tornjevi[i - 1].Ciljanje(
NeprijateljiRect, metakIkona))
if dmgLista != []:
for j in dmgLista:
for i in j:
if i[0] > -1 and listaNeprijatelj:
listaNeprijatelj[i[0]].damage(i[1])
if listaNeprijatelj[i[0]].vratiHP() < 1:
smrtZvuk.play(0)
UI.azurirajNovce(5)
listaNeprijatelj.remove(listaNeprijatelj[i[0]])
lvlSeed.smanjiBrojNep()
indekas = GlZgrada.damage(NeprijateljiRect)
if indekas > -1:
listaNeprijatelj.remove(listaNeprijatelj[indekas])
indekas = -1
trenutnoNeprijatelja, ukupnoNeprijatelja = lvlSeed.ukupnoNeprijatelja(
)
UI.ispisStanja(GlZgrada.vratiHP(), trenutnoNeprijatelja,
ukupnoNeprijatelja)
#uvijeti kraja igre
if GlZgrada.vratiHP()[0] <= 0 or (len(listaNeprijatelj) < 1
and pocetak == 0):
pygame.mixer.music.fadeout(1000)
pygame.mixer.music.load('glazba/menu.ogg')
pygame.mixer.music.play()
pocetak = 1
if GlZgrada.vratiHP()[0] <= 0:
print("Izgubljeno")
mod = modIzgubljeno
else:
print("Pobjeda")
mod = modPobjeda
odabraniLvl = None
listaNeprijatelj = []
grid = []
UI.postaviNovce(0)
lvlSeed.reset()
startVrijeme = 1
startKliknut = 0
if audio:
pygame.mixer.unpause()
pygame.mixer.music.set_volume(0.3)
else:
pygame.mixer.pause()
pygame.mixer.music.set_volume(0)
POVRSINA.blit(kursor, pygame.mouse.get_pos())
pygame.display.update()
POVRSINA.blit(pozadina, ((0, 0), (840, 480)))
FPSCLOCK.tick(FPS)
pygame.quit()
# coding=utf-8
from mapa import Mapa
from lineal import *
mapa = Mapa()
print('')
print('')
print('Estamos volando en la tranquilidad del espacio.....')
print('')
print('')
print(' __')
print(' \ \_____')
print(' ---[==_____>')
print(' /_/')
print('')
print('')
def editar_mapa():
global mapa_X, mapa_Y
mapa_X = 15
mapa_Y = 15
# Inicializar ecrã
tamanho = (400, 300)
ecra = pygame.display.set_mode(tamanho)
# Fonte
fonteTexto = pygame.font.SysFont("Comic Sans MS", 30)
fonteSinais = pygame.font.SysFont("Comic Sans MS", 25)
fonteTituloMenu = pygame.font.Font("fonte.ttf", 43)
# Texto que contem o tamanho do mapa e botão para alterar o tamanho do mapa
def botao(texto, centro, raio, funcionalidade, executar, ecra):
def rato_porCima(centro, raio):
posicao_rato = pygame.mouse.get_pos()
distancia = sqrt((posicao_rato[X] - centro[X])**2 +
(posicao_rato[Y] - centro[Y])**2)
return distancia <= raio
# Renderizar o botão
cor = (50, 50, 50) if rato_porCima(centro, raio) else (60, 60, 60)
pygame.draw.circle(ecra, cor, centro, raio)
# Sinal
sinal = fonteSinais.render(texto, True, COR_TEXTO)
text_width, text_height = fonteSinais.size(texto)
posicao_info = (centro[X] - text_width // 2,
centro[Y] - text_height // 2)
ecra.blit(sinal, posicao_info)
# Executar funcionalidade do botão
if executar and rato_porCima(centro, raio):
funcionalidade()
def selecinador_tamanho(texto, valor, posicao, raio, func_aumento,
func_diminuicao, executar, ecra):
texto_display = fonteTexto.render(str(valor), True, (171, 173, 175))
text_width, text_height = fonteTexto.size(str(valor))
posicao_info = (posicao[X] - text_width // 2,
posicao[Y] - text_height // 2)
# Informação sobre o tamanho do mapa
ecra.blit(texto_display, posicao_info)
DISTANCIA_AO_TEXTO = raio // 2
# Botão de diminuir
DISTANCIA_TEXTO_CENTRO = raio + DISTANCIA_AO_TEXTO
botao("-", (posicao_info[X] - DISTANCIA_TEXTO_CENTRO, posicao[Y]),
raio, func_diminuicao, executar, ecra)
# Botão de aumento
botao("+", (posicao_info[X] + text_width + DISTANCIA_TEXTO_CENTRO,
posicao[Y]), raio, func_aumento, executar, ecra)
# Texto :
titulo = fonteTituloMenu.render(texto, True, COR_TEXTO)
text_width, text_height = fonteTituloMenu.size(str(texto))
posicao_texto = (posicao[X] - text_width // 2,
posicao[Y] - text_height // 2 - raio * 2)
ecra.blit(titulo, posicao_texto)
# Linha :
ESPACO_LINHA_TEXTO = 5
OFFSET = 30
linha = pygame.Rect(posicao_texto[X] - OFFSET // 2,
posicao[Y] - raio - GROSSURA - ESPACO_LINHA_TEXTO,
text_width + OFFSET, GROSSURA)
pygame.draw.rect(ecra, COR_LINHA, linha)
# Funções dos botões
def aumenta_mapaX():
global mapa_X
mapa_X += 1
def aumenta_mapaY():
global mapa_Y
mapa_Y += 1
def diminui_mapaX():
global mapa_X
if mapa_X > 1:
mapa_X -= 1
def diminui_mapaY():
global mapa_Y
if mapa_Y > 1:
mapa_Y -= 1
# Display loop :
a_correr = True
update = True
while a_correr:
clicado = False
# Receber eventos
for evento in pygame.event.get():
if evento.type == pygame.QUIT:
quit()
# Verificar se o botão do rato foi clicado
elif evento.type == pygame.MOUSEBUTTONUP:
clicado = True
# Uma tecla foi primida
elif evento.type == pygame.KEYDOWN:
if evento.key == ENTER:
a_correr = False
# Update dos conteúdos do ecrã
# Update do background
ecra.fill(COR_BACKGROUND)
# Display do texto
selecinador_tamanho("Largura do mapa", mapa_X,
(tamanho[X] // 2, (3 * tamanho[Y]) // 9), 25,
aumenta_mapaX, diminui_mapaX, clicado, ecra)
selecinador_tamanho("Altura do mapa", mapa_Y,
(tamanho[X] // 2, (7 * tamanho[Y]) // 9), 25,
aumenta_mapaY, diminui_mapaY, clicado, ecra)
# Dar update do ecrã
pygame.display.update()
update = False
mapa = Mapa(mapa_X, mapa_Y, Snake([]), [], True)
return mapa
matrix[i, 6] = 3
matrix[2, 6] = 2
pared1 = Pared(0, 0, 1, 0)
pared2 = Pared(1, 0, 1, 1)
pared3 = Pared(2, 0, 2, 1)
pared4 = Pared(3, 0, 3, 1)
paredes = [pared1, pared2, pared3, pared4]
personaje = Personaje(4, 2)
monstruo = Monstruo(1, 0)
mapa = Mapa(matrix, paredes, monstruo, personaje)
""" NIVEL 1
matrix = np.zeros((7, 6))
for i in range(0,6):
matrix[6,i] = 3
matrix[6,3] = 2
matrix[1,1] = 1
pared1 = Pared(0,5,1,5)
pared2 = Pared(1,4,1,5)
pared3 = Pared(5,5,5,4)
pared4 = Pared(0,3,1,3)
for monstruo in monstruos:
if (distancia(monstruo.posicion, self.posicion) <= 2):
monstruo.defender(self.atacar())
elif event.type == MOUSEBUTTONDOWN:
print((event.pos[0] // LADO_CELDA, event.pos[1] // LADO_CELDA))
self.movimientos = mapa.buscar_camino(
self.posicion,
(event.pos[1] // LADO_CELDA, event.pos[0] // LADO_CELDA))
print(self.movimientos)
if (len(self.movimientos) > 0):
self.posicion = self.movimientos.pop(0)
mapa = Mapa(ANCHO_MAPA, ALTO_MAPA, LADO_CELDA)
mapa.generar_aleatorio()
mapa.generar_automata()
jugador = Jugador((0, 0))
monstruos = [
Monstruo((0, ANCHO_MAPA - 1)),
Monstruo((ALTO_MAPA - 1, ANCHO_MAPA - 1)),
Monstruo((ALTO_MAPA - 1, 0))
]
while True:
jugador.actualizar(pygame.event.get())
mapa.mostrar_mapa()
from mapa import Mapa
from robot import Robot
from monedas import Monedas
import time
import utilidades
nombre_mapa = "mapas/" + (input("Ingrese: ")) + ".txt"
lista_mapa = utilidades.cargar_mapa(nombre_mapa)
nombre_instrucciones = "instrucciones/" + (input("Ingrese: ")) + ".txt"
lista_instrucciones = utilidades.cargar_instrucciones(nombre_instrucciones)
#print(lista_mapa)
#print(lista_instrucciones)
objeto_mapa = Mapa((len(lista_mapa[0])) , (len(lista_mapa)))
for i in range(len(lista_mapa)):
for j in range(len(lista_mapa[0])):
if lista_mapa[i][j] == "*":
objeto_robot = Robot(j ,i)
objeto_robot.agregar_mapa(objeto_mapa)
objeto_mapa.agregar_robot(objeto_robot)
elif int(lista_mapa[i][j]) > 0:
for k in range(int(lista_mapa[i][j])):
objeto_moneda = Monedas(j , i)
objeto_mapa.agregar_moneda(objeto_moneda)
#print(objeto_mapa.contar_monedas(j , i))
print("")
print("Monedas en el mapa: " , objeto_mapa.monedas_en_mapa())
print("Tus monedas: " , objeto_robot.monedas)
print(objeto_mapa.dibujar())
from utilidades import cargar_mapa, cargar_instrucciones
from mapa import Mapa
from robot import Robot
import time
nombre_mapa = "mapas/" + (input("Ingrese el nombre del mapa: ")) + ".txt"
el_mapa = cargar_mapa(nombre_mapa)
nombre_instrucciones = "instrucciones/" + (
input("Ingrese el nombre de las instrucciones: ")) + ".txt"
instrucciones = cargar_instrucciones(nombre_instrucciones)
objeto_mapa = Mapa(el_mapa) #Crea el objeto Mapa
objeto_robot = Robot() #Crea el objeto Robot
objeto_mapa.asignar_robot(objeto_robot) #Asigna robot a mapa
objeto_robot.asignar_mapa(objeto_mapa) #Asigna mapa a robot
objeto_robot.buscar_robot() #Busca el robot
print()
print("Robot: ", objeto_robot.x, ",", objeto_robot.y,
objeto_robot.direccion) #Imprime posicion y direccion del robot
print(objeto_mapa.imprimir_mapa())
print()
for instruccion in instrucciones:
print(instruccion)
if instruccion == "MOVE":
objeto_robot.MOVE()
#print(objeto_mapa.imprimir_mapa())
objeto_mapa.fichas_posicion_robot()
if objeto_mapa.fichas_posicion_actual > 0:
print("Fichas en el lugar: ", objeto_mapa.fichas_posicion_actual)
import pygame
from interface import Tela
from interface import Cor
from mapa import Mapa
import busca
from busca import Problema
from agente import Goku
import pontos
map = Mapa("Mapa01.txt", Tela.LARGURA / 42, Tela.ALTURA / 42)
mapEsferas = [(1, 4), (39, 5), (19, 9), (3, 22), (37, 27), (36, 29), (22, 37)]
#mapEsferas = [(0,0), (0,41), (41,0), (41,41), (25,35), (25,19), (30,10)]
#mapEsferas = pontos.esferasAleatorias()
NUM_ESFERAS = len(mapEsferas)
#Pontos Focais
focos = pontos.pontosFocaisPadrao()
INICIO = (19, 19)
fim = pontos.maisProximo(INICIO, focos)
prob = Problema(INICIO, fim, map)
agente = Goku(prob)
esferas = agente.radar(mapEsferas)
esferasAvistadas = []
esferasColetadas = []
for e in esferas:
mapEsferas.remove(e)
esferasAvistadas.append(e)
if len(esferas) > 0:
fim = pontos.maisProximo(agente.estadoAtual.id, esferas)
esferas.remove(fim)
def game_loop():
""" Main do jogo """
# Ler mapa guardado :
with open("mapa.txt") as ficheiro:
tamanho = eval(ficheiro.readline())
paredes = eval(ficheiro.readline())
# Inicialização do mapa
pos_inicial = [tamanho[X] // 2, tamanho[Y] // 2]
cobra = Snake([pos_inicial, [pos_inicial[X], pos_inicial[Y] - 1]])
mapa = Mapa(tamanho[X], tamanho[Y], cobra, paredes, False)
# Calculo das posições / tamanho do mapa em relação ao tamanho
# da janela e calculo do tamanho necessario para a janela
tamanho_mapa = ((mapa.tamanho[X] * MAPA_TAMANHO) + ((mapa.tamanho[X] - 1) * MAPA_INTERVALO), \
(mapa.tamanho[Y] * MAPA_TAMANHO) + ((mapa.tamanho[Y] - 1) * MAPA_INTERVALO))
pos_mapa = (MAPA_TAMANHO, 120)
tamanho = (tamanho_mapa[X] + 2 * pos_mapa[X],
tamanho_mapa[Y] + pos_mapa[X] + pos_mapa[Y])
# Ecrã
ecra = pygame.display.set_mode(tamanho)
# Header
titulo = "The Snake"
the_snake = fonteTitulo.render(titulo, True, COR_TEXTO)
text_width, text_height = fonteTitulo.size(
titulo) # Dimenções do retangulo que involve o texto
# Centrar o texto em relação a posição do mapa
pos_texto = (tamanho[X] // 2 - text_width // 2, 10)
# Linha por baixo do titulo
pos_retangulo = (pos_mapa[X], pos_texto[Y] + text_height + DISTANCIA_TEXTO)
retangulo = pygame.Rect(pos_retangulo[X], pos_retangulo[Y],
tamanho_mapa[X], GROSSURA)
# Score :
score = "Score :"
pos_score = (pos_retangulo[X], pos_retangulo[Y] + GROSSURA + 5)
score_width, score_height = fonteScore.size(score)
pos_pontos = (pos_score[X] + score_width + 10, pos_score[Y])
# FPS
clock = pygame.time.Clock()
# Game loop :
a_correr = True
while a_correr:
clock.tick(FPS)
ecra.fill(COR_BACKGROUND)
# Titulo
ecra.blit(the_snake, pos_texto)
pygame.draw.rect(ecra, COR_LINHA, retangulo)
# Score
score_texto = fonteScore.render(score, True, (140, 142, 143))
pontos_texto = fonteScore.render(str(cobra.score), True, COR_TEXTO)
ecra.blit(score_texto, pos_score)
ecra.blit(pontos_texto, pos_pontos)
tecla = None
# Receber eventos
for evento in pygame.event.get():
if evento.type == pygame.QUIT:
quit()
# Uma tecla foi primida
elif evento.type == pygame.KEYDOWN:
# Funcionalidade para cada tecla
tecla = chr(evento.key)
# Update da cobra
a_correr = cobra.update(mapa, tecla)
# Dar display do mapa
mapa.display(pos_mapa, ecra, cobra)
# Dar update do ecrã
pygame.display.update()
def juego(surface, fps_clock):
""" Hace funcionar el juego en si, empezando la carrera"""
#-Creamos los jugadores e inicializamos los datos
jugador1 = coche.Coche(
perfil.coche_j1
) # Nombre, velocidad máxima, aceleración, turbo, manejo, frenada
jugador2 = coche.Coche(
perfil.coche_j2
) # Nombre, velocidad máxima, aceleración, turbo, manejo, frenada
iniciar_datos_jugador(jugador1, perfil.coche_j1, (640, 35))
iniciar_datos_jugador(jugador2, perfil.coche_j2, (640, 75))
#-Creamos el mapa
mapa = Mapa()
mapa.crear(1) # Creamos el mapa según el nivel seleccionado
tiles_hierba = mapa.dibujar(surface)
#-Cargamos la música
sonido_motor_j1 = pygame.mixer.Sound(
"Sonidos/Sonido Motor.wav") # Cargamos el sonido de un motor
sonido_motor_j1.play()
sonido_motor_j1.set_volume(
0
) # Ponemos el volumen a 0, pues está condicionado por la velocidad del coche (empieza a 0)
sonido_motor_j2 = pygame.mixer.Sound(
"Sonidos/Sonido Motor.wav") # Cargamos el sonido de un motor
sonido_motor_j2.play()
sonido_motor_j2.set_volume(
0
) # Ponemos el volumen a 0, pues está condicionado por la velocidad del coche (empieza a 0)
#-Creamos algunas variables
pausa = False # Indica si el juego está en pausa o no
#================================BUCLE============================
while True:
if pausa == True: # Si el juego está en pausa
sonido_motor_j1.stop()
sonido_motor_j2.stop()
pausa = False # False para que una vez cerrada la función de menu_pausa el juego no siga en pausa
jugador1.corriendo, jugador1.frenando, jugador1.girando, jugador1.turbeando = False, False, False, False
jugador2.corriendo, jugador2.frenando, jugador2.girando, jugador2.turbeando = False, False, False, False
salir = menu.menu_pausa(
surface, fps_clock
) # Activamos el menú de pausa, que devuelve True si se le da a salir
if salir == True: # Si volvió al menú principal
iniciar_datos_jugador(jugador1, perfil.coche_j1, (640, 35))
iniciar_datos_jugador(jugador2, perfil.coche_j2, (640, 75))
else:
sonido_motor_j1.play()
sonido_motor_j2.play()
for event in pygame.event.get():
tecla_pulsada = pygame.key.get_pressed()
if event.type == QUIT:
pygame.quit()
sys.exit()
elif event.type == KEYDOWN:
#------------------Jugador 1
if event.key == K_UP:
jugador1.corriendo = True
elif event.key == K_DOWN:
jugador1.frenando = True
jugador1.turbeando = False
elif event.key == K_KP0:
jugador1.turbeando = True
elif event.key == K_RIGHT:
jugador1.girando = 'derecha'
elif event.key == K_LEFT:
jugador1.girando = 'izquierda'
#------------------Jugador 2
elif event.key == K_w:
jugador2.corriendo = True
elif event.key == K_s:
jugador2.frenando = True
jugador2.turbeando = False
elif event.key == K_SPACE:
jugador2.turbeando = True
elif event.key == K_d:
jugador2.girando = 'derecha'
elif event.key == K_a:
jugador2.girando = 'izquierda'
#--Menu de pausa
elif event.key == K_p:
pausa = True
elif event.type == KEYUP:
#------------------Jugador 1
if event.key == K_UP:
jugador1.corriendo = False
jugador1.turbeando = False
if tecla_pulsada[K_DOWN]:
jugador1.frenando = True
elif event.key == K_DOWN:
jugador1.frenando = False
if tecla_pulsada[K_UP]:
jugador1.corriendo = True
elif event.key == K_KP0:
jugador1.turbeando = False
elif event.key == K_RIGHT:
jugador1.girando = False
if tecla_pulsada[K_LEFT]:
jugador1.girando = 'izquierda'
elif event.key == K_LEFT:
jugador1.girando = False
if tecla_pulsada[K_RIGHT]:
jugador1.girando = 'derecha'
#------------------Jugador 2
elif event.key == K_w:
jugador2.corriendo = False
jugador2.turbeando = False
if tecla_pulsada[K_s]:
jugador2.frenando = True
elif event.key == K_s:
jugador2.frenando = False
if tecla_pulsada[K_w]:
jugador2.corriendo = True
elif event.key == K_SPACE:
jugador2.turbeando = False
elif event.key == K_d:
jugador2.girando = False
if tecla_pulsada[K_a]:
jugador2.girando = 'izquierda'
elif event.key == K_a:
jugador2.girando = False
if tecla_pulsada[K_d]:
jugador2.girando = 'derecha'
#------------------Calculamos datos y variables y aplicamos sonidos (actualizamos la posición de cada jugador, la ajustamos si es necesario y cambiamos la imagen)
#-Jugador 1
jugador1.actualizar_movimiento(tiles_hierba) # Actualizamos los datos
if jugador1.velocidad > 0: # Si la velocidad es mayor que 0
sonido_motor_j1.set_volume(jugador1.velocidad / 100)
else: # Si la velocidad es menor que 0
sonido_motor_j1.set_volume(jugador1.velocidad * -1 / 100)
#-Jugador 2
jugador2.actualizar_movimiento(tiles_hierba) # Actualizamos los datos
if jugador2.velocidad > 0: # Si la velocidad es mayor que 0
sonido_motor_j2.set_volume(jugador2.velocidad / 100)
else: # Si la velocidad es menor que 0
sonido_motor_j2.set_volume(jugador2.velocidad * -1 / 100)
#================================UPDATE============================
#------------------Mapa
mapa.dibujar(surface) # Dibujamos el mapa en el surface
#------------------Coches
surface.blit(jugador1.image, (jugador1.rect.x, jugador1.rect.y))
surface.blit(jugador2.image, (jugador2.rect.x, jugador2.rect.y))
#------------------Marcadores
# Para la versión 2.0
#------------------Update, FPS
pygame.display.update()
fps_clock.tick(FPS)
def __init__(self):
x = int(input("Defina o valor máximo do eixo X:"))
y = int(input("Defina o maior valor do eixo Y:"))
self.mapa = Mapa(x, y)
from personagem import Personagem
from tipo_personagem import TipoPersonagem
from mapa import Mapa
QTD_INIMIGOS_INICIAIS = 3
print("=========================")
print("Bem vindo ao Dungeon Bash!")
print("=========================")
arena = Mapa()
arena.jogador.CriarJogador()
arena.jogador.ExibirDadosDoJogador()
usr_input = input("Pressione ENTER para começar")
level = 1
while usr_input != "0":
qtdInimigos = QTD_INIMIGOS_INICIAIS + (QTD_INIMIGOS_INICIAIS % level)
qtdInimigos = qtdInimigos + 2 if qtdInimigos == level else qtdInimigos
arena.GerarInimigos(qtdInimigos, level)
arena.ExibirDadosDosInimigos()
arena.Batalhar()
if not arena.jogador.ativo:
break
level += 1
arena.jogador.AumentarLevel(level)
usr_input = input("Continuar para o level %s?\nPerssione ENTER para confirmar, para sair digite 0: " %level)
def crear_mapa(self):
try:
return Mapa(self.filas.get(), self.columnas.get())
except tk.TclError:
return self.mapa
linha_skills = componenetes_dev[3::]
list_devs.append(Replyer(i, company, bonus, linha_skills))
i += 1
list_pos = []
i = 0
for po in linhas_pos:
po.replace("\n", '')
company, bonus = po.split()
list_pos.append(Replyer(i, company, bonus))
i += 1
return mapa_final, list_devs, list_pos
mapa_final, list_devs, list_pos = read_input(sys.argv[1])
mapa_ = Mapa(mapa_final)
mapa_.config_map()
mapa_.set_random(list_devs, list_pos)
max_score = -1
while (True):
if random.random() < 0.42:
x, y = mapa_.pegar_o_mais_fdp()
mapa_.random_swap_fdp(x, y, list_devs, list_pos)
else:
mapa_.set_random(list_devs, list_pos)
score = mapa_.get_score(list_devs, list_pos)
if max_score < score:
max_score = score
output_devs = list()
def generar_laberinto(filas, columnas):
"""Generar un laberinto.
Argumentos:
filas, columnas (int): Tamaño del mapa
Devuelve:
Mapa: un mapa nuevo con celdas bloqueadas formando un laberinto
aleatorio
"""
mapa = Mapa(filas, columnas)
for i in range(0, filas):
for j in range(0, columnas):
coordenada = Coord(i, j)
mapa.bloquear(coordenada)
mapa.asignar_origen(Coord(1, 1))
if columnas % 2 != 0 and filas % 2 != 0:
mapa.asignar_destino(Coord(filas - 2, columnas - 2))
else:
if columnas % 2 != 0:
mapa.asignar_destino(Coord(filas - 1, columnas - 2))
if filas % 2 != 0:
mapa.asignar_destino(Coord(filas - 2, columnas - 1))
coord = mapa.origen()
camino = Pila()
camino.apilar(coord)
visitadas = set()
while not camino.esta_vacia():
coord = camino.ver_tope()
mapa.desbloquear(coord)
visitadas.add(coord)
celdas_vecinas = [
mapa.trasladar_coord(coord, 2, 0),
mapa.trasladar_coord(coord, -2, 0),
mapa.trasladar_coord(coord, 0, 2),
mapa.trasladar_coord(coord, 0, -2)
]
vecinas = celdas_vecinas[:]
for vecina in vecinas:
if vecina == coord:
celdas_vecinas.remove(vecina)
elif not mapa.celda_bloqueada(vecina):
celdas_vecinas.remove(vecina)
if (len(celdas_vecinas) == 0) or (coord == mapa.destino()):
camino.desapilar()
continue
vecina_aleatoria = randint(0, len(celdas_vecinas) - 1)
coord_vecina = celdas_vecinas[vecina_aleatoria]
if coord_vecina in visitadas:
continue
desbloquear_celda_medio(mapa, coord, coord_vecina)
camino.apilar(coord_vecina)
return mapa
