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 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 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.
Si hay mas de un heroe en la definicion del mapa, o bien si no hay ningun
heroe, la funcion lanza una excepcion.
`filas` es una lista de strings, que corresponde con el contenido completo
del archivo .map."""
####
#### Modificar este codigo para que cargue el mapa dinamicamente
#### a partir de `filas`
####
mapa = Mapa(10, 10)
heroe = actores.Heroe()
mapa.agregar_actor(heroe, 5, 5)
return mapa, heroe
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 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 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 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 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 __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
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 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 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
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()
class TelaDeJogo(Tela):
""" Tela responsavel pelo nivel em si
Guarda algumas das variaveis utilizadas no jogo,
enquanto outras pertencem ao mapa sendo utilizado
@param superficie: superficie pygame
@param nivel: nome do nivel a ser carregado
@param slot: slot de jogo salvo selecionado
"""
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 salvar_jogo(self):
"Salva o jogo ao ganhar ou perder"
slots = DAOJogo.saves
slots[self.__slot] = [
self.__nivel, self.__nivel,
type(self.__jogador.poder).__name__,
type(self.__jogador.poder_armazenado).__name__,
self.__jogador.paleta
]
DAOJogo.saves = slots
def atualizar(self, ciclo):
'''Logica de jogo, envolvendo controles, colisao e renderizacao
Deve ser chamada pela funcdao gerente 60 vezes por segundo
@param ciclo: responsavel pelas frames de animacao do Rabisco
@returns: Instancia da proxima tela a ser executada apos o nivel
[False] se o jogo for fechado,
[True] se o jogo continuar na frame seguinte
'''
if isinstance(self.__sobreposicao, Sobreposicao): pausado = True
else: pausado = False
if not pausado:
for evento in pygame.event.get():
if evento.type == pygame.QUIT:
self.salvar_jogo()
return [False]
if evento.type == pygame.KEYDOWN:
if evento.key == pygame.K_w: self.__cima = 5
if evento.key == pygame.K_s: self.__baixo = 5
if evento.key == pygame.K_d:
self.__direita = 0.5
if evento.key == pygame.K_a:
self.__esquerda = 0.5
if evento.key == pygame.K_SPACE or evento.key == pygame.K_w:
self.__espaco = True
if evento.key == pygame.K_ESCAPE:
self.__sobreposicao = TelaPause(self)
if evento.key == pygame.K_TAB:
self.__troca_poder = True
if evento.type == pygame.KEYUP:
if evento.key == pygame.K_w: self.__cima = 0
if evento.key == pygame.K_s: self.__baixo = 0
if evento.key == pygame.K_d:
self.__direita = 0
if evento.key == pygame.K_a:
self.__esquerda = 0
if evento.key == pygame.K_SPACE or evento.key == pygame.K_w:
self.__espaco = False
if evento.key == pygame.K_TAB:
self.__troca_poder = False
if evento.type == pygame.MOUSEBUTTONDOWN:
self.__bola_fogo = True
elif evento.type == pygame.MOUSEBUTTONUP:
self.__bola_fogo = False
else:
for evento in pygame.event.get():
if evento.type == pygame.QUIT:
self.salvar_jogo()
return False
if evento.type == pygame.KEYDOWN:
if evento.key == pygame.K_ESCAPE:
self.__sobreposicao = None
self.__direita = 0
self.__esquerda = 0
self.__cima = 0
self.__baixo = 0
self.__espaco = False
self.__bola_fogo = False
self.__troca_poder = False
##### FILA DE RENDERIZACAO E ATUALIZACAO #####
self.__mapa.atualizar(self.superficie, self.__campo_visivel,
self.superficie.get_size(), ciclo)
# FAZER O JOGADOR RECEBER UM MAPA E SALVAR ONDE ELE TA
if self.__atrasofim > 0:
self.__direita = 0
self.__esquerda = 0
self.__espaco = not self.__mapa.ganhou
else:
self.__jogador.poderes(self.superficie, self.__mapa,
self.__bola_fogo)
self.__campo_visivel = self.__jogador.atualizar(
self.superficie, self.__mapa, [
self.__direita, self.__esquerda, self.__espaco,
self.__troca_poder
])
# PERDENDO POR MORRER
if self.__jogador.vida <= 0 and not self.__mapa.ganhou:
self.__jogador.vida_pra_zero()
self.__atrasofim += 1
if self.__atrasofim <= 1:
self.__textin = self.__fonte.render("FIM DE JOGO", False,
(0, 0, 0))
pygame.mixer.music.fadeout(2400)
if self.__mapa.escala_tempo > 1:
self.__textin = pygame.font.SysFont(
'msminchomspmincho',
48).render("神の御名（みめい）においてしりそける", False, (0, 0, 0))
else:
self.__jogador.tipos_transparentes = self.__classes_instanciaveis
self.superficie.blit(
self.__textin,
(self.__campo_visivel.w / 2 - self.__textin.get_size()[0] / 2,
self.__campo_visivel.h / 2 - self.__textin.get_size()[1] / 2))
if self.__atrasofim >= 150:
self.salvar_jogo()
return [
FimDeJogo, [self.superficie, self.__nivel, self.__slot]
]
### VENCENDO ###
if self.__mapa.ganhou:
self.__atrasofim += 1
#if self.__atrasofim <= 1:
#pygame.mixer.music.fadeout(2400)
self.__textin = self.__fonte.render("VITÓRIA", False, (0, 0, 0))
self.superficie.blit(
self.__textin,
(self.__campo_visivel.w / 2 - self.__textin.get_size()[0] / 2,
self.__campo_visivel.h / 2 - self.__textin.get_size()[1] / 2))
if self.__atrasofim >= 150:
self.salvar_jogo()
return [
TelaDeJogo,
[self.superficie, self.__mapa.proxima_fase, self.__slot]
] if self.__mapa.proxima_fase else [
MenuPrincipal, [self.superficie]
]
##### TELA DE PAUSE NO JOGO #####
try:
resultado = self.__sobreposicao.atualizar(ciclo)
if not resultado:
self.__sobreposicao = None
elif resultado == "Fechar":
self.salvar_jogo()
pygame.mixer.music.fadeout(500)
return [
FimDeJogo, [self.superficie, self.__nivel, self.__slot]
]
except AttributeError:
pass
### FLIP PARA PASSAR PARA A TELA, LOGICA DE TEMPO
pygame.display.flip()
self.__tempo_maximo += (1 - self.__mapa.escala_tempo) / 60
tempo_decorrido = pygame.time.get_ticks() / 1000 - self.__comeco
if not self.__mapa.ganhou:
self.__mapa.tempo_restante = int(
max(self.__tempo_maximo - tempo_decorrido, 0))
### PERDENDO POR TEMPO
if self.__mapa.tempo_restante == 0:
self.__jogador.vida_pra_zero()
return [True]
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)
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)
# 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('')
class Robo:
"""
Robo
Variaveis do estado:
x , y , angulo: posicao do robo no ambiente.
raio: tamanho do robo.
vel_motor_direita , vel_motor_esquerda: utilizadas na dinamica do robo
"""
class Params:
VELOCIDADE_MAXIMA_MOTOR = 2
REDUCAO_MOTOR_CORREDOR = 0.99 # reducao percentual da velocidade maxima usada no controle. Padrao: 0.99
REDUCAO_MOTOR_CAMPO_ABERTO = 0.90 # reducao percentual da velocidade maxima usada no controle. Padrao: 0.99
VARIACAO_MOTORES = 0.1 # variacao aleatoria na velocidade dos motores. Padrao: 0.1 (10% maximo)
DISTANCIA_MINIMA_PARADA = 15 # distancia minima de uma parede a frente. Padrao: 15
LARGURA_CORREDOR = 60 # Padrao: 60
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 mostra_direcao(self):
if self.direcao == Direcoes.NORTE:
print("NORTE")
if self.direcao == Direcoes.SUL:
print("SUL")
if self.direcao == Direcoes.LESTE:
print("LESTE")
if self.direcao == Direcoes.OESTE:
print("OESTE")
if self.direcao == 0:
print("INDEFINIDA")
def determina_direcao(self):
self.direcao = 0
if (self.angulo <= math.pi / 4) and (self.angulo > -math.pi / 4):
self.direcao = Direcoes.LESTE
if (self.angulo > math.pi / 4) and (self.angulo <= 3 * math.pi / 4):
self.direcao = Direcoes.NORTE
if (self.angulo < -math.pi / 4) and (self.angulo >= -3 * math.pi / 4):
self.direcao = Direcoes.SUL
if (self.angulo > 3 * math.pi / 4) or (self.angulo < -3 * math.pi / 4):
self.direcao = Direcoes.OESTE
class Estados(enum.Enum):
ANDA = 1 # anda indefinidamente
ANDA1 = 2 # anda uma celula
PARA = 3
GIRA_DIREITA = 4
GIRA_ESQUERDA = 5
def mostra_estado(self):
if self.estado == self.Estados.ANDA:
print("ANDA")
if self.estado == self.Estados.ANDA1:
print("ANDA1")
elif self.estado == self.Estados.PARA:
print("PARA")
elif self.estado == self.Estados.GIRA_DIREITA:
print("GIRA_DIREITA")
elif self.estado == self.Estados.GIRA_ESQUERDA:
print("GIRA_ESQUERDA")
elif self.estado == self.Estados.GIRA_PARA:
print("PARA")
@staticmethod
def rotaciona(x, y, angulo):
x_rotacionado = x * math.cos(angulo) - y * math.sin(angulo)
y_rotacionado = x * math.sin(angulo) + y * math.cos(angulo)
return x_rotacionado, y_rotacionado
def atualiza_sensores(self, lista_obstaculos):
"""
Atualiza a leitura dos sensores
"""
for sensor in self.sensores_distancia:
sensor.inicializa()
for obstaculo in lista_obstaculos:
for sensor in self.sensores_distancia:
coord_x_rotacionada, coord_y_rotacionada = self.rotaciona(
sensor.coord_x_relativa, sensor.coord_y_relativa,
self.angulo)
coord_x_absoluta = self.coord_x + coord_x_rotacionada
coord_y_absoluta = self.coord_y + coord_y_rotacionada
sensor.determina_distancia_obstaculo(
coord_x_absoluta, coord_y_absoluta,
self.angulo + sensor.angulo_relativo, obstaculo)
def verifica_colisao(self, lista_obstaculos, coord_x_prevista,
coord_y_prevista):
restringe_x = False
restringe_y = False
for obstaculo in lista_obstaculos:
x1 = obstaculo[0]
y1 = obstaculo[1]
x2 = obstaculo[2]
y2 = obstaculo[3]
limite_direito = coord_x_prevista + self.raio
limite_esquerdo = coord_x_prevista - self.raio
limite_superior = coord_y_prevista - self.raio
limite_inferior = coord_y_prevista + self.raio
if ((limite_direito > x1) and
(limite_direito < x2)) or ((limite_esquerdo > x1) and
(limite_esquerdo < x2)):
if (limite_inferior < y1) and (limite_inferior > y2) or (
limite_superior < y1) and (limite_superior > y2):
restringe_x = True
restringe_y = True
if restringe_x:
coord_x_final = self.coord_x
else:
coord_x_final = coord_x_prevista
if restringe_y:
coord_y_final = self.coord_y
else:
coord_y_final = coord_y_prevista
return coord_x_final, coord_y_final
def dinamica_robo(self, lista_obstaculos):
"""
Atualiza a posicao e angulo do robo com base no algoritmo de controle.
"""
self.atualiza_sensores(lista_obstaculos)
self.controle()
velocidade = (self.vel_motor_direita + self.vel_motor_esquerda) / 2
self.angulo = self.angulo + (self.vel_motor_direita -
self.vel_motor_esquerda) * math.pi / 24
if self.angulo > math.pi:
self.angulo -= 2 * math.pi
if self.angulo < -math.pi:
self.angulo += 2 * math.pi
coord_x_prevista = self.coord_x + velocidade * math.cos(self.angulo)
coord_y_prevista = self.coord_y + velocidade * math.sin(self.angulo)
self.coord_x, self.coord_y = self.verifica_colisao(
lista_obstaculos, coord_x_prevista, coord_y_prevista)
self.determina_direcao()
# self.mostra_direcao()
dist_frente = self.sensores_distancia[0].distancia
dist_esquerda = self.sensores_distancia[1].distancia
dist_direita = self.sensores_distancia[2].distancia
if (self.estado == self.Estados.ANDA) or (self.estado
== self.Estados.ANDA1):
self.mapa.atualiza(self.coord_x, self.coord_y, dist_frente,
dist_esquerda, dist_direita, self.direcao)
if self.estado == self.Estados.PARA:
self.avanca_sequencia_de_comandos()
self.algoritmo_de_movimentacao.loop(self)
def avanca_sequencia_de_comandos(self):
#self.mostra_estado()
if len(self.lista_de_comandos) > 0:
self.estado = self.lista_de_comandos[0]
del self.lista_de_comandos[0]
if self.estado == self.Estados.ANDA1:
if (self.direcao == Direcoes.LESTE) or (self.direcao
== Direcoes.OESTE):
self.contagem = int(
self.mapa.fator_escala_x /
self.Params.VELOCIDADE_MAXIMA_MOTOR) + 1
if (self.direcao == Direcoes.NORTE) or (self.direcao
== Direcoes.SUL):
self.contagem = int(
self.mapa.fator_escala_y /
self.Params.VELOCIDADE_MAXIMA_MOTOR) + 1
if self.estado == self.Estados.GIRA_DIREITA:
if self.ideal:
self.contagem = 9
else:
self.contagem = 8 + random.randint(0, 2)
if self.estado == self.Estados.GIRA_ESQUERDA:
if self.ideal:
self.contagem = 9
else:
self.contagem = 8 + random.randint(0, 2)
#self.mostra_estado()
def aberto_direita(self):
celula_atual = self.mapa.celula_atual()
if self.direcao == Direcoes.OESTE:
if celula_atual.aberto_norte:
return True
if self.direcao == Direcoes.LESTE:
if celula_atual.aberto_sul:
return True
if self.direcao == Direcoes.NORTE:
if celula_atual.aberto_leste:
return True
if self.direcao == Direcoes.SUL:
if celula_atual.aberto_oeste:
return True
return False
def aberto_esquerda(self):
celula_atual = self.mapa.celula_atual()
if self.direcao == Direcoes.OESTE:
if celula_atual.aberto_sul:
return True
if self.direcao == Direcoes.LESTE:
celula_atual = self.mapa.celula_atual()
if celula_atual.aberto_norte:
return True
if self.direcao == Direcoes.NORTE:
celula_atual = self.mapa.celula_atual()
if celula_atual.aberto_oeste:
return True
if self.direcao == Direcoes.SUL:
celula_atual = self.mapa.celula_atual()
if celula_atual.aberto_leste:
return True
return False
def aberto_adiante(self):
celula_atual = self.mapa.celula_atual()
if self.direcao == Direcoes.OESTE:
if celula_atual.aberto_oeste:
return True
if self.direcao == Direcoes.LESTE:
if celula_atual.aberto_leste:
return True
if self.direcao == Direcoes.NORTE:
if celula_atual.aberto_norte:
return True
if self.direcao == Direcoes.SUL:
if celula_atual.aberto_sul:
return True
return False
def controle(self):
"""
Algoritmo de controle dos motores do robo.
O robo eh controlado por:
self.vel_motor_direita
self.vel_motor_esquerda
Os sensores são lidos na configuracao atual do robo em:
self.sensores_distancia[0].distancia # frontal;
self.sensores_distancia[1].distancia # esquerdo;
self.sensores_distancia[2].distancia # direito;
O estado atual do robo pode ser lido em:
self.estado
e pode ser:
self.Estados.ANDA - anda ate encontrar uma parede;
self.Estados.ANDA1 - anda uma celula a frente e para;
self.Estados.GIRA_DIREITA - gira para a direita;
self.Estados.GIRA_ESQUERDA - gira para a esquerda;
O tempo em cada etapa eh controlado por
self.contagem
"""
dist_frontal = self.sensores_distancia[0].distancia
dist_esquerda = self.sensores_distancia[1].distancia
dist_direita = self.sensores_distancia[2].distancia
#self.mostra_estado()
if (self.estado == self.Estados.ANDA) or (self.estado
== self.Estados.ANDA1):
if dist_frontal > self.Params.DISTANCIA_MINIMA_PARADA:
if self.ideal:
self.vel_motor_direita = self.Params.VELOCIDADE_MAXIMA_MOTOR
self.vel_motor_esquerda = self.Params.VELOCIDADE_MAXIMA_MOTOR
else:
self.vel_motor_direita = self.Params.VELOCIDADE_MAXIMA_MOTOR + self.Params.VARIACAO_MOTORES * random.random(
)
self.vel_motor_esquerda = self.Params.VELOCIDADE_MAXIMA_MOTOR + self.Params.VARIACAO_MOTORES * random.random(
)
if not self.ideal:
if dist_direita + dist_esquerda < self.Params.LARGURA_CORREDOR:
if dist_direita > dist_esquerda:
self.vel_motor_direita = self.Params.VELOCIDADE_MAXIMA_MOTOR * self.Params.REDUCAO_MOTOR_CORREDOR
if dist_esquerda > dist_direita:
self.vel_motor_esquerda = self.Params.VELOCIDADE_MAXIMA_MOTOR * self.Params.REDUCAO_MOTOR_CORREDOR
else:
if dist_direita > dist_esquerda:
if dist_esquerda > self.dist_esquerda_anterior:
self.vel_motor_esquerda = self.Params.VELOCIDADE_MAXIMA_MOTOR * self.Params.REDUCAO_MOTOR_CAMPO_ABERTO
self.vel_motor_direita = self.Params.VELOCIDADE_MAXIMA_MOTOR
else:
self.vel_motor_direita = self.Params.VELOCIDADE_MAXIMA_MOTOR * self.Params.REDUCAO_MOTOR_CAMPO_ABERTO
self.vel_motor_esquerda = self.Params.VELOCIDADE_MAXIMA_MOTOR
if dist_esquerda > dist_direita:
if dist_direita > self.dist_direita_anterior:
self.vel_motor_direita = self.Params.VELOCIDADE_MAXIMA_MOTOR * self.Params.REDUCAO_MOTOR_CAMPO_ABERTO
self.vel_motor_esquerda = self.Params.VELOCIDADE_MAXIMA_MOTOR
else:
self.vel_motor_esquerda = self.Params.VELOCIDADE_MAXIMA_MOTOR * self.Params.REDUCAO_MOTOR_CAMPO_ABERTO
self.vel_motor_direita = self.Params.VELOCIDADE_MAXIMA_MOTOR
else:
if self.direcao == Direcoes.LESTE:
self.angulo = 0
elif self.direcao == Direcoes.OESTE:
self.angulo = math.pi
elif self.direcao == Direcoes.NORTE:
self.angulo = math.pi / 2
elif self.direcao == Direcoes.LESTE:
self.angulo = -math.pi / 2
if dist_frontal < self.Params.DISTANCIA_MINIMA_PARADA:
self.vel_motor_direita = 0
self.vel_motor_esquerda = 0
self.estado = self.Estados.PARA
if self.estado == self.Estados.ANDA1:
self.contagem -= 1
if self.contagem == 0:
self.estado = self.Estados.PARA
if self.estado == self.Estados.PARA:
self.vel_motor_direita = 0
self.vel_motor_esquerda = 0
if self.estado == self.Estados.GIRA_DIREITA:
self.vel_motor_direita = -self.Params.VELOCIDADE_MAXIMA_MOTOR / 3
self.vel_motor_esquerda = self.Params.VELOCIDADE_MAXIMA_MOTOR / 3
self.contagem = self.contagem - 1
if self.contagem == 0:
self.estado = self.Estados.PARA
if self.estado == self.Estados.GIRA_ESQUERDA:
self.vel_motor_direita = self.Params.VELOCIDADE_MAXIMA_MOTOR / 3
self.vel_motor_esquerda = -self.Params.VELOCIDADE_MAXIMA_MOTOR / 3
self.contagem = self.contagem - 1
if self.contagem == 0:
self.estado = self.Estados.PARA
#self.mostra_estado()
self.dist_esquerda_anterior = self.dist_esquerda_anterior * 0.7 + dist_esquerda * 0.3
self.dist_direita_anterior = self.dist_direita_anterior * 0.7 + dist_direita * 0.3
class Jogo(cocos.scene.Scene):
def __init__(self):
super(Jogo, self).__init__()
self.estado = {
'linhas': 0,
'colunas': 0,
'pontuacao': 0,
'robo': None,
'meta': None,
'pedras': [],
'pontos': []
}
self.inicializarEstado()
self.teclado = None
self.inicializarTeclado()
self.mapa = None
self.inicializarMapa()
self.painel = None
self.inicializarPainel()
# O Estado vem todo a partir de um ficheiro de inicialização.
def inicializarEstado(self):
# Vai abrir a ficheiro 'informacao_inicial.txt' e dividir o
# conteúdo em vários pedaços de texto.
file = open("info-inicial.txt", "r")
content = file.read()
tokens = content.split()
# Extrair o tamanho do mapa.
self.estado['linhas'] = int(tokens[0])
self.estado['colunas'] = int(tokens[1])
# Extrair a posição do robo
xRobo = int(tokens[2])
yRobo = int(tokens[3])
self.robo = Unidade('robo', (xRobo, yRobo))
# Extrair a posição da meta
xMeta = int(tokens[4])
yMeta = int(tokens[5])
self.meta = Unidade('meta', (xRobo, xMeta))
# Extrair a quantidade de pedras e posiciona-las.
# @TODO: Ainda pode gerar por cima do robo ou outras unidades.
numeroPedras = int(tokens[6])
for l in range(1, numeroPedras + 1):
xPedra = random.randint(1, self.estado['linhas'])
yPedra = random.randint(1, self.estado['colunas'])
novaPedra = Unidade('pedra', (xPedra, yPedra))
self.estado['pedras'].append(novaPedra)
# Extrair a quantidade de pontos e posiciona-las.
# @TODO: Ainda pode gerar por cima do robo ou outras unidades.
numeroPontos = int(tokens[7])
for l in range(1, numeroPontos + 1):
xPonto = random.randint(1, self.estado['linhas'])
yPonto = random.randint(1, self.estado['colunas'])
novoPonto = Unidade('ponto', (xPonto, yPonto))
self.estado['pontos'].append(novoPonto)
def inicializarTeclado(self):
self.teclado = Teclado(self)
self.add(self.teclado)
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 inicializarPainel(self):
self.painel = Painel()
self.add(self.painel)
# Move o robo e executa o método de actualizão.
def moverRobo(self, movimento):
posicaoDesejada = (self.robo.posicao[0] + movimento[0],
self.robo.posicao[1] + movimento[1])
if (self.podeMover(posicaoDesejada)):
self.robo.posicao = posicaoDesejada
# É necessário actualizar sempre a unidade no mapa
# depois de mexer nela.
self.mapa.actualizarUnidade(self.robo)
self.aposMover()
# Verifica se o robo se pode mover para a posicaoDesejada.
# Aqui é importante ver se um robo pode mover para cima de
# uma pedra ou assim.
def podeMover(self, posicaoDesejada):
# @TODO preencher
return True
# Esta função faz acontecer coisas depois do movimento do
# robo. Por exemplo, as coisas que acontecem quando um robo
# está por cima de uma moeda ou de uma meta.
def aposMover(self):
# @TODO preencher
return
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)
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()
from mapa import Mapa
from sistema import Sistema
from radar import Radar
from estadisticas import Estadisticas
from copy import copy
n = 15
lista_1 = [Barco(), Guerra(), Lancha(), Puerto(), Explorador(), IXXI(), Caza()]
lista_2 = [Barco(), Guerra(), Lancha(), Puerto(), Explorador(), IXXI(), Caza()]
# input si es Oponente o computador
player = "Jugador"
otro = "Oponente"
mapa_1 = Mapa(player, n)
mapa_2 = Mapa(otro, n)
radar_1 = Radar()
radar_2 = Radar()
estadisticas_1 = Estadisticas(player, otro)
estadisticas_2 = Estadisticas(otro, player)
def leer(texto):
aux = input(texto)
exit(0) if aux == "exit" else None
return aux
def mapear(mapa, lista):
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()
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()
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 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 crear_mapa(self):
try:
return Mapa(self.filas.get(), self.columnas.get())
except tk.TclError:
return self.mapa
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.
Si hay mas de un heroe en la definicion del mapa, o bien si no hay ningun
heroe, la funcion lanza una excepcion.
`filas` es una lista de strings, que corresponde con el contenido completo
del archivo .map."""
#There is no hero, create the map.
posHero = 0
mapa = Mapa(len(filas[0]), len(filas))
#Invert the list of str
reverse = zip(*filas)
for i in xrange(len(reverse)):
reverse[i] = ''.join(reverse[i])
filas = reverse
del reverse
#for each line in the list of str
for i, line in enumerate(filas):
#for each character in the str
for j, char in enumerate(line):
#si el caracter es @
if(char == '@'):
#Si hay hero
if posHero == 0:
#Nuevo hero
posHero = (i, j)
else:
#Sino : Error, Hay dos !
raise Exception("Hay 2 heroes en la mapa")
# Agrega los actores a la map
if(char == '#'):
mapa.agregar_actor(actores.Pared(), i,j)
if(char == 'g'):
mapa.agregar_actor(actores.Goblin(), i,j)
if(char == 'o'):
mapa.agregar_actor(actores.Orco(), i,j)
if(char == '$'):
mapa.agregar_actor(actores.Moneda(100), i,j)
if(char == '<'):
mapa.agregar_actor(actores.Salida(), i,j)
# Si no hay heroe : Exception
if posHero == 0:
raise Exception("No hay heroe en la mapa")
# Cree el horoe
heroe = actores.Heroe()
# Lo agrega a la map
mapa.agregar_actor(heroe, posHero[0], posHero[1])
return mapa, heroe
# 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()
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)
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 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())
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
class Tela_De_Jogo(Tela):
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
def atualizar(self, ciclo):
for evento in pygame.event.get():
if evento.type == pygame.QUIT:
return 0
if evento.type == pygame.KEYDOWN:
if evento.key == pygame.K_w: self.__cima = 5
if evento.key == pygame.K_s: self.__baixo = 5
if evento.key == pygame.K_d:
self.__direita = 0.5
if evento.key == pygame.K_a:
self.__esquerda = 0.5
if evento.key == pygame.K_SPACE or evento.key == pygame.K_w:
self.__espaco = True
if evento.type == pygame.KEYUP:
if evento.key == pygame.K_w: self.__cima = 0
if evento.key == pygame.K_s: self.__baixo = 0
if evento.key == pygame.K_d:
self.__direita = 0
if evento.key == pygame.K_a:
self.__esquerda = 0
if evento.key == pygame.K_SPACE or evento.key == pygame.K_w:
self.__espaco = False
if evento.type == pygame.MOUSEBUTTONDOWN: self.__bola_fogo = True
elif evento.type == pygame.MOUSEBUTTONUP: self.__bola_fogo = False
##### FILA DE RENDERIZACAO #####
self.__superficie.fill(
self.__background_colour) # Preenaa a com o a cor de fundo
self.__mapa.atualizar(self.__superficie, self.__campo_visivel,
self.__superficie.get_size())
# FAZER O JOGADOR RECEBER UM MAPA E SALVAR ONDE ELE TA
if self.__atrasofim > 0:
self.__direita = 0
self.__esquerda = 0
self.__espaco = 0
self.__jogador.mover(self.__direita, self.__esquerda, self.__espaco,
self.__superficie.get_size(), self.__mapa,
self.__atrito)
self.__jogador.poderes(self.__superficie, self.__mapa,
self.__bola_fogo)
self.__campo_visivel = self.__jogador.atualizar(
self.__superficie, self.__campo_visivel, int(ciclo / 6))
# PERDENDO POR MORRER
if self.__jogador.vida <= 0 and not self.__mapa.ganhou:
self.__jogador.vida_pra_zero()
self.__atrasofim += 1
textin = self.__fonte.render("PERDEU", 0, (0, 0, 0))
self.__superficie.blit(textin, (500, 300))
if self.__atrasofim >= 150:
return 1
### VENCENDO ###
if self.__mapa.ganhou:
self.__atrasofim += 1
textin = self.__fonte.render("VENCEU", 0, (0, 0, 0))
self.__superficie.blit(textin, (500, 300))
if self.__atrasofim >= 150:
return 3
##### RENDERIZACAO DA TELA #####
pygame.display.flip()
tempo_decorrido = int((pygame.time.get_ticks() / 1000) - self.__comeco)
self.__mapa.conta = self.__tempo_maximo - tempo_decorrido
##### PASSANDO A VIDA PRO DISPLAY #####d
self.__mapa.vida_jogador = self.__jogador.vida
### PERDENDO POR TEMPO
if self.__mapa.conta == 0:
self.__jogador.vida_pra_zero()
return 2
