def actualizar(self):
if pilas.escena_actual().control.izquierda:
self.x -= 5
self.espejado = True
elif pilas.escena_actual().control.derecha:
self.x += 5
self.espejado = False
def actualizar(self):
if pilas.escena_actual().control.izquierda:
self.x -= 5
self.espejado = True
elif pilas.escena_actual().control.derecha:
self.x += 5
self.espejado = False
def dibuja_al_actor(self, motor, painter, lienzo, actor):
lienzo.circulo(painter,
actor.x - pilas.escena_actual().camara.x,
actor.y - pilas.escena_actual().camara.y,
actor.radio_de_colision,
color=pilas.colores.verde,
grosor=ModoDepurador.grosor_de_lineas)
def perder(self, mensaje):
self.vidas = 3
pilas.actores.Actor.decir(self, mensaje)
self.definir_imagen(self.image_perdio)
pilas.avisar("Para regresar al menu presione la tecla 'Esc'")
mensaje = pilas.actores.Texto("Perdiste!!!")
pilas.escena_actual().tareas.eliminar_todas()
def __init__(self,
receptor,
control=None,
direcciones=OCHO_DIRECCIONES,
velocidad_maxima=4,
aceleracion=1,
deceleracion=0.1,
con_rotacion=False,
velocidad_rotacion=1,
marcha_atras=True):
Habilidad.__init__(self, receptor)
pilas.escena_actual().actualizar.conectar(self.on_key_press)
if control == None:
self.control = self.receptor.escena.control
else:
self.control = control
self.direcciones = direcciones
self.velocidad = 0
self.deceleracion = deceleracion
self._velocidad_maxima = velocidad_maxima
self._aceleracion = aceleracion
self.con_rotacion = con_rotacion
self.velocidad_rotacion = velocidad_rotacion
self.marcha_atras = marcha_atras
def _realizarMovimiento(self, vel, seconds):
""" El robot avanza con velocidad vel durante seconds segundos. """
def adelanteSinTiempo():
self.actor.hacer(pilas.comportamientos.Avanzar(self.actor.velocidad, self.actor.velocidad))
return (self.movimiento)
def atrasSinTiempo():
self.actor.hacer(pilas.comportamientos.Retroceder(self.actor.velocidad, self.actor.velocidad))
return (self.movimiento)
self.stop()
self._setVelocidad(vel)
if (self._velocidadValida(vel, 10, 100)) :
self.movimiento = True
self.tarea = pilas.escena_actual().tareas.condicional(0.1, adelanteSinTiempo)
if (seconds != -1):
wait(seconds)
self.stop()
elif (self._velocidadValida(vel, -100, -10)) :
self.movimiento = True
self.tarea = pilas.escena_actual().tareas.condicional(0.1, atrasSinTiempo)
self.actor.velocidad = self.actor.velocidad * -1
if (seconds != -1):
wait(seconds)
self.stop()
else:
print """ Rangos de velocidades válidas:
def __init__(self, texto="None", x=0, y=0, magnitud=17, autoeliminar=False, retraso=5):
"""Inicializa el texto.
:param texto: Texto a mostrar.
:param x: Posición horizontal.
:param y: Posición vertical.
:param magnitud: Tamaño del texto.
:param vertical: Si el texto será vertical u horizontal, como True o False.
"""
Texto.__init__(self, texto, x, y, magnitud)
izquierda, derecha, arriba, abajo = pilas.utils.obtener_bordes()
# Se asegura de que solo exista un texto inferior
if TextoInferior.anterior_texto:
TextoInferior.anterior_texto.eliminar()
self.z = -100
TextoInferior.anterior_texto = self
self._crear_sombra()
self.centro = ("centro", "centro")
self.izquierda = izquierda + 10
self.color = pilas.colores.blanco
self.abajo = abajo + 10
self.fijo = True
if autoeliminar:
pilas.escena_actual().tareas.una_vez(retraso, self.eliminar)
def cuando_termina_de_arrastrar(self, evento):
"Suelta al actor porque se ha soltado el botón del mouse."
pilas.escena_actual().mueve_mouse.desconectar_por_id(
id='cuando_arrastra')
self.termina_de_arrastrar()
pilas.escena_actual().termina_click.desconectar_por_id(
id='cuando_termina_de_arrastrar')
def comenzar(self):
y = 300 #comienzo de la lista
self.mono = pilas.actores.Mono()
#self.mono.aprender(pilas.habilidades.SeguirClicks)
self.mono.z = 1
self.mono.escala = 0
self.mono.radio_de_colision = 10
self.mono.x = 500
self.mono.click_de_mouse(self.mover_al_mono)
for elem in self.lista_de_nombre:
self.m = pilas.actores.Texto(
texto=elem,
magnitud=55,
fuente='./escenas/interfazusuario/AGENCYB.TTF')
self.m.radio_de_colision = 15
self.lista_de_botones.append(self.m)
y = y - 75
self.m.y = y
self.m.x = -800
self.m.z = -5
pilas.escena_actual().colisiones.agregar(self.mono,
self.lista_de_botones,
self.cambiar_escena)
def BeginContact(self, *args, **kwargs):
objeto_colisionado_1 = args[0].fixtureA
objeto_colisionado_2 = args[0].fixtureB
if (not objeto_colisionado_1.userData == None) and (not objeto_colisionado_2.userData == None):
pilas.escena_actual().colisiones.verificar_colisiones_fisicas(objeto_colisionado_1.userData['id'],
objeto_colisionado_2.userData['id'])
def eliminar_a_todos():
a_eliminar = pilas.escena_actual().actores[1:] # evita borrar el fondo.
for x in a_eliminar:
x.eliminar()
pilas.escena_actual().actores = []
def __init__(self, grilla=None, x=0, y=0, filas=20, columnas=20):
"""Inicializa el mapa.
:param grilla: La imagen a utilizar cómo grilla con los bloques del escenario.
:param x: Posición horizontal del mapa.
:param y: Posición vertical del mapa.
:param filas: Cantidad de filas que tendrá el mapa.
:param columnas: Cantidad de columnas que tendrá el mapa.
"""
Actor.__init__(self, 'invisible.png', x, y)
self.filas = filas
self.columnas = columnas
# Genera una matriz indicando cuales de los bloque son solidos.
self.matriz_de_bloques = self._generar_matriz_de_bloques(filas, columnas)
if not grilla:
grilla = pilas.imagenes.cargar_grilla("grillas/plataformas_10_10.png", 10, 10)
self.grilla = grilla
self.superficie = pilas.imagenes.cargar_superficie(columnas * self.grilla.cuadro_ancho, filas * self.grilla.cuadro_alto)
#self.imagen = self.superficie
self.centro_mapa_x, self.centro_mapa_y = self.superficie.centro()
pilas.escena_actual().mueve_camara.conectar(self._actualizar_imagen)
self.fijo = True
def _set_x(self, x):
"""Define la posición horizontal de la cámara.
:param x: Posición horizontal.
"""
pilas.escena_actual().mueve_camara.emitir(x=x, y=self.y, dx=x-self.x, dy=0)
pilas.mundo.motor.definir_centro_de_la_camara(x, self.y)
def cuando_intenta_arrastrar(self, evento):
"Intenta mover el objeto con el mouse cuando se pulsa sobre el."
if (evento.boton == 1):
if self.receptor.colisiona_con_un_punto(evento.x, evento.y):
pilas.escena_actual().termina_click.conectar(self.cuando_termina_de_arrastrar, id='cuando_termina_de_arrastrar')
pilas.escena_actual().mueve_mouse.conectar(self.cuando_arrastra, id='cuando_arrastra')
self.comienza_a_arrastrar()
def cuando_arrastra(self, evento):
"Arrastra el actor a la posicion indicada por el puntero del mouse."
if self._el_receptor_tiene_fisica():
pilas.escena_actual().fisica.cuando_mueve_el_mouse(evento.x, evento.y)
else:
self.receptor.x += evento.dx
self.receptor.y += evento.dy
def _realizarGiro(self, vel, seconds):
def izquierdaSinTiempo():
self.actor.hacer(
pilas.comportamientos.Girar(-abs(self.actor.velocidad),
self.actor.velocidad))
return (self.movimiento)
def derechaSinTiempo():
self.actor.hacer(
pilas.comportamientos.Girar(abs(self.actor.velocidad),
self.actor.velocidad))
return (self.movimiento)
self.stop()
self._setVelocidad(vel)
if (self._velocidadValida(vel, 10, 100)):
self.movimiento = True
self.tarea = pilas.escena_actual().tareas.condicional(
0.1, derechaSinTiempo)
if (seconds != -1):
wait(seconds)
self.stop()
elif (self._velocidadValida(vel, -100, -10)):
self.movimiento = True
self.tarea = pilas.escena_actual().tareas.condicional(
0.1, izquierdaSinTiempo)
self.actor.velocidad = self.actor.velocidad * -1
if (seconds != -1):
wait(seconds)
self.stop()
else:
print """ Rangos de velocidades válidas:
def perder(arma, enemigo):
enemigo.sonreir()
arma.eliminar()
pilas.escena_actual().tareas.eliminar_todas()
fin_de_juego = True
pilas.avisar("HAS PERDIDO. Conseguiste %d putnos" %(puntos.obtener()))
def _verificar_colisiones_fisicas_en_tupla(self, tupla, id_actor_a, id_actor_b):
"Toma dos grupos de actores y analiza colisiones entre ellos."
(grupo_a, grupo_b, funcion_a_llamar) = tupla
for a in grupo_a:
for b in grupo_b:
try:
if self._es_objeto_fisico_con_actor_asociado(a):
a_id = a.figura.id
else:
a_id = a.id
if self._es_objeto_fisico_con_actor_asociado(b):
b_id = b.figura.id
else:
b_id = b.id
if a_id == id_actor_a and b_id == id_actor_b:
funcion_a_llamar(a, b)
# verifica si alguno de los dos objetos muere en la colision.
if (self._es_objeto_fisico_con_actor_asociado(a)):
if a not in pilas.escena_actual().actores:
if a in grupo_a:
list.remove(grupo_a, a)
if (self._es_objeto_fisico_con_actor_asociado(b)):
if b not in pilas.escena_actual().actores:
if b in grupo_b:
list.remove(grupo_b, b)
except Exception as e:
list.remove(grupo_a, a)
raise e
def _realizarMovimiento(self, vel, seconds):
""" El robot avanza con velocidad vel durante seconds segundos. """
def adelanteSinTiempo():
self.actor.hacer(
pilas.comportamientos.Avanzar(self.actor.velocidad,
self.actor.velocidad))
return (self.movimiento)
def atrasSinTiempo():
self.actor.hacer(
pilas.comportamientos.Retroceder(self.actor.velocidad,
self.actor.velocidad))
return (self.movimiento)
self.stop()
self._setVelocidad(vel)
if (self._velocidadValida(vel, 10, 100)):
self.movimiento = True
self.tarea = pilas.escena_actual().tareas.condicional(
0.1, adelanteSinTiempo)
if (seconds != -1):
wait(seconds)
self.stop()
elif (self._velocidadValida(vel, -100, -10)):
self.movimiento = True
self.tarea = pilas.escena_actual().tareas.condicional(
0.1, atrasSinTiempo)
self.actor.velocidad = self.actor.velocidad * -1
if (seconds != -1):
wait(seconds)
self.stop()
else:
print """ Rangos de velocidades válidas:
def actualizar(self):
if pilas.escena_actual().control.izquierda:
x = self.objeto_a_imitar.x-32
y = self.objeto_a_imitar.y
self.receptor.x = x
self.receptor.y = y
if pilas.escena_actual().control.derecha:
x = self.objeto_a_imitar.x+32
y = self.objeto_a_imitar.y
self.receptor.x = x
self.receptor.y = y
if pilas.escena_actual().control.abajo:
x = self.objeto_a_imitar.x
y = self.objeto_a_imitar.y-32
self.receptor.x = x
self.receptor.y = y
if pilas.escena_actual().control.arriba:
x = self.objeto_a_imitar.x
y = self.objeto_a_imitar.y+32
self.receptor.x = x
self.receptor.y = y
if (self.con_rotacion):
self.receptor.rotacion = self.objeto_a_imitar.rotacion
def definir_gravedad(x, y):
"""Define la gravedad del motor de física.
:param x: Aceleración horizontal.
:param y: Aceleración vertical.
"""
pilas.escena_actual().fisica.definir_gravedad(x, y)
def actualizar(self):
self.avanzar_animacion()
vx = 0
if pilas.escena_actual().control.izquierda:
vx = -(self.receptor.velocidad)
if not self.receptor.espejado:
self.receptor.espejado = True
#self.receptor.x -= VELOCIDAD
self.receptor.obtener_colisiones()
if not (self.receptor.colisiona_arriba_izquierda
or self.receptor.colisiona_abajo_izquierda):
self.receptor.x += vx
elif pilas.escena_actual().control.derecha:
vx = self.receptor.velocidad
if self.receptor.espejado:
self.receptor.espejado = False
#self.receptor.x += VELOCIDAD
self.receptor.obtener_colisiones()
if not (self.receptor.colisiona_arriba_derecha
or self.receptor.colisiona_abajo_derecha):
self.receptor.x += vx
else:
self.receptor.hacer(Esperando())
if pilas.escena_actual().control.arriba:
self.receptor.hacer(Saltando(-9))
self.caer_si_no_toca_el_suelo()
def __init__(self,
texto="None",
x=0,
y=0,
magnitud=17,
autoeliminar=False,
retraso=5):
"""Inicializa el texto.
:param texto: Texto a mostrar.
:param x: Posición horizontal.
:param y: Posición vertical.
:param magnitud: Tamaño del texto.
:param vertical: Si el texto será vertical u horizontal, como True o False.
"""
Texto.__init__(self, texto, x, y, magnitud)
izquierda, derecha, arriba, abajo = pilas.utils.obtener_bordes()
# Se asegura de que solo exista un texto inferior
if TextoInferior.anterior_texto:
TextoInferior.anterior_texto.eliminar()
self.z = -100
TextoInferior.anterior_texto = self
self._crear_sombra()
self.centro = ("centro", "centro")
self.izquierda = izquierda + 10
self.color = pilas.colores.blanco
self.abajo = abajo + 10
self.fijo = True
if autoeliminar:
pilas.escena_actual().tareas.una_vez(retraso, self.eliminar)
def definir_gravedad(x, y):
"""Define la gravedad del motor de física.
:param x: Aceleración horizontal.
:param y: Aceleración vertical.
"""
pilas.escena_actual().fisica.definir_gravedad(x, y)
def __init__(self, receptor, control=None, direcciones=OCHO_DIRECCIONES, velocidad_maxima=4,
aceleracion=1, deceleracion=0.1, con_rotacion=False, velocidad_rotacion=1, marcha_atras=True):
"""Inicializa la habilidad.
:param receptor: Referencia al actor que aprenderá la habilidad.
:param control: Control al que va a responder para mover el Actor.
:param direcciones: Establece si puede mover en cualquier direccion o unicamente en 4 direcciones arriba, abajo, izquierda y derecha. El parametro con_rotacion establece las direcciones a OCHO_DIRECCIONES siempre.
:param velocidad_maxima: Velocidad maxima en pixeles a la que se moverá el Actor.
:param aceleracion: Indica lo rapido que acelera el actor hasta su velocidad máxima.
:param deceleracion: Indica lo rapido que decelera el actor hasta parar.
:param con_rotacion: Si deseas que el actor rote pulsando las teclas de izquierda y derecha.
:param velocidad_rotacion: Indica lo rapido que rota un actor sobre si mismo.
:param marcha_atras: Posibilidad de ir hacia atrás. (True o False)
"""
Habilidad.__init__(self, receptor)
pilas.escena_actual().actualizar.conectar(self.on_key_press)
if control == None:
self.control = self.receptor.escena.control
else:
self.control = control
self.direcciones = direcciones
self.velocidad = 0
self.deceleracion = deceleracion
self._velocidad_maxima = velocidad_maxima
self._aceleracion = aceleracion
self.con_rotacion = con_rotacion
self.velocidad_rotacion = velocidad_rotacion
self.marcha_atras = marcha_atras
def _set_y(self, y):
"""Define la posición vertical de la cámara.
:param y: Posición vertical.
"""
pilas.escena_actual().mueve_camara.emitir(x=self.x, y=y, dx=0, dy=y-self.y)
pilas.mundo.motor.definir_centro_de_la_camara(self.x, y)
def actualizar(self):
self.avanzar_animacion()
vx = 0
if pilas.escena_actual().control.izquierda:
vx = -(self.receptor.velocidad)
self.receptor.espejado = True
self.receptor.habilidades.Disparar.angulo_salida_disparo = 90
self.receptor.obtener_colisiones()
if not(self.receptor.colisiona_arriba_izquierda or self.receptor.colisiona_abajo_izquierda):
self.receptor.x += vx
elif pilas.escena_actual().control.derecha:
vx = self.receptor.velocidad
self.receptor.espejado = False
self.receptor.habilidades.Disparar.angulo_salida_disparo = -90
self.receptor.obtener_colisiones()
if not(self.receptor.colisiona_arriba_derecha or self.receptor.colisiona_abajo_derecha):
self.receptor.x += vx
else:
self.receptor.hacer(Esperando())
if pilas.escena_actual().control.arriba:
self.receptor.hacer(Saltando(-8))
self.caer_si_no_toca_el_suelo()
def actualizar(self):
self.velocidad_de_salto += 0.25
distancia = self.receptor.obtener_distancia_al_suelo()
# Si toca el suelo se detiene.
if self.velocidad_de_salto > distancia:
self.receptor.y -= distancia
self.receptor.hacer(Esperando())
else:
self.receptor.y -= self.velocidad_de_salto
# obtiene la veloridad del personaje para detectar cuando
# toca el suelo.
vx, vy = 0, 0 #self.receptor.figura.obtener_velocidad_lineal()
if pilas.escena_actual().control.izquierda:
vx = -(self.receptor.velocidad)
self.receptor.espejado = True
self.receptor.habilidades.Disparar.angulo_salida_disparo = 90
self.receptor.obtener_colisiones()
if not(self.receptor.colisiona_arriba_izquierda or self.receptor.colisiona_abajo_izquierda):
self.receptor.x += vx
elif pilas.escena_actual().control.derecha:
vx = self.receptor.velocidad
self.receptor.espejado = False
self.receptor.habilidades.Disparar.angulo_salida_disparo = -90
self.receptor.obtener_colisiones()
if not(self.receptor.colisiona_arriba_derecha or self.receptor.colisiona_abajo_derecha):
self.receptor.x += vx
def _verificar_colisiones_fisicas_en_tupla(self, tupla, id_actor_a, id_actor_b):
"Toma dos grupos de actores y analiza colisiones entre ellos."
(grupo_a, grupo_b, funcion_a_llamar) = tupla
for a in grupo_a:
for b in grupo_b:
try:
if self._es_objeto_fisico_con_actor_asociado(a):
a_id = a.figura.id
else:
a_id = a.id
if self._es_objeto_fisico_con_actor_asociado(b):
b_id = b.figura.id
else:
b_id = b.id
if a_id == id_actor_a and b_id == id_actor_b:
funcion_a_llamar(a, b)
# verifica si alguno de los dos objetos muere en la colision.
if (self._es_objeto_fisico_con_actor_asociado(a)):
if a not in pilas.escena_actual().actores:
if a in grupo_a:
list.remove(grupo_a, a)
if (self._es_objeto_fisico_con_actor_asociado(b)):
if b not in pilas.escena_actual().actores:
if b in grupo_b:
list.remove(grupo_b, b)
except Exception as e:
list.remove(grupo_a, a)
raise e
def cuando_colisionan2(protagonista2, bombas):
"""Es la funcion que se ejecuta cuando se pierde"""
for i in range(len(self.bombas)):
self.bombas[i].eliminar()
self.temporizador.eliminar()
pilas.escena_actual().tareas.eliminar_todas()
self.perdiste.reproducir()
textoo=pilas.actores.Texto("PERDISTE!! =S")
textoo.y=70
textoo.color=pilas.colores.rojo
texto3=pilas.actores.Texto("Tu puntaje: " + self.puntaje.obtener_texto())
texto3.y=130
texto3.color=pilas.colores.rojo
fondo = pilas.fondos.Fondo("loser.png")
fondo.escala = 1.30
self.musica.detener()
def iniciar_juego_de_nuevo(): #Inicia de nuevo el juego
pilas.cambiar_escena(Juego())
def volver_menu(): #Vuelve al menu principal
pilas.mundo.motor.mostrar_puntero_del_mouse()
pilas.cambiar_escena(Menu())
def salir_del_juego(): #sale del juego
pilas.terminar()
self.moneda.eliminar()
def guarda_puntaje():
pilas.mundo.motor.mostrar_puntero_del_mouse()
puntaje = self.puntaje.obtener_texto()
pilas.cambiar_escena(GuardarPuntaje(puntaje))
menu = pilas.actores.Menu([("Reiniciar juego", iniciar_juego_de_nuevo),
("Volver al menu principal", volver_menu),
("Guardar puntaje", guarda_puntaje),
("Salir", salir_del_juego),
])
menu.color = pilas.colores.rojo
def cuando_arrastra(self, evento):
"Arrastra el actor a la posicion indicada por el puntero del mouse."
if self._el_receptor_tiene_fisica():
pilas.escena_actual().fisica.cuando_mueve_el_mouse(evento.x, evento.y)
else:
self.receptor.x += evento.dx
self.receptor.y += evento.dy
def cuando_intenta_arrastrar(self, evento):
"Intenta mover el objeto con el mouse cuando se pulsa sobre el."
if (evento.boton == 1):
if self.receptor.colisiona_con_un_punto(evento.x, evento.y):
pilas.escena_actual().termina_click.conectar(self.cuando_termina_de_arrastrar, id='cuando_termina_de_arrastrar')
pilas.escena_actual().mueve_mouse.conectar(self.cuando_arrastra, id='cuando_arrastra')
self.comienza_a_arrastrar()
def eliminar_a_todos():
a_eliminar = pilas.escena_actual().actores[1:] # evita borrar el fondo.
for x in a_eliminar:
x.eliminar()
pilas.escena_actual().actores = []
def actualizar(self):
self.velocidad_de_salto += 0.25
distancia = self.receptor.obtener_distancia_al_suelo()
# Si toca el suelo se detiene.
if self.velocidad_de_salto > distancia:
self.receptor.y -= distancia
self.receptor.hacer(Esperando())
else:
self.receptor.y -= self.velocidad_de_salto
# obtiene la veloridad del personaje para detectar cuando
# toca el suelo.
vx, vy = 0, 0 #self.receptor.figura.obtener_velocidad_lineal()
if pilas.escena_actual().control.izquierda:
vx = -(self.receptor.velocidad)
self.receptor.espejado = True
self.receptor.habilidades.Disparar.angulo_salida_disparo = 90
self.receptor.obtener_colisiones()
if not (self.receptor.colisiona_arriba_izquierda
or self.receptor.colisiona_abajo_izquierda):
self.receptor.x += vx
elif pilas.escena_actual().control.derecha:
vx = self.receptor.velocidad
self.receptor.espejado = False
self.receptor.habilidades.Disparar.angulo_salida_disparo = -90
self.receptor.obtener_colisiones()
if not (self.receptor.colisiona_arriba_derecha
or self.receptor.colisiona_abajo_derecha):
self.receptor.x += vx
def __init__(self,
texto="None",
x=0,
y=0,
magnitud=17,
autoeliminar=False,
retraso=5):
Texto.__init__(self, texto, x, y, magnitud)
izquierda, derecha, arriba, abajo = pilas.utils.obtener_bordes()
# Se asegura de que solo exista un texto inferior
if TextoInferior.anterior_texto:
TextoInferior.anterior_texto.eliminar()
self.z = -100
TextoInferior.anterior_texto = self
self._crear_sombra()
self.centro = ("centro", "centro")
self.izquierda = izquierda + 10
self.color = pilas.colores.blanco
self.abajo = abajo + 10
self.fijo = True
if autoeliminar:
pilas.escena_actual().tareas.una_vez(retraso, self.eliminar)
def __init__(self, receptor, control=None, direcciones=OCHO_DIRECCIONES, velocidad_maxima=4,
aceleracion=1, deceleracion=0.1, con_rotacion=False, velocidad_rotacion=1, marcha_atras=True):
"""Inicializa la habilidad.
:param receptor: Referencia al actor que aprenderá la habilidad.
:param control: Control al que va a responder para mover el Actor.
:param direcciones: Establece si puede mover en cualquier direccion o unicamente en 4 direcciones arriba, abajo, izquierda y derecha. El parametro con_rotacion establece las direcciones a OCHO_DIRECCIONES siempre.
:param velocidad_maxima: Velocidad maxima en pixeles a la que se moverá el Actor.
:param aceleracion: Indica lo rapido que acelera el actor hasta su velocidad máxima.
:param deceleracion: Indica lo rapido que decelera el actor hasta parar.
:param con_rotacion: Si deseas que el actor rote pulsando las teclas de izquierda y derecha.
:param velocidad_rotacion: Indica lo rapido que rota un actor sobre si mismo.
:param marcha_atras: Posibilidad de ir hacia atrás. (True o False)
"""
Habilidad.__init__(self, receptor)
pilas.escena_actual().actualizar.conectar(self.on_key_press)
if control == None:
self.control = self.receptor.escena.control
else:
self.control = control
self.direcciones = direcciones
self.velocidad = 0
self.deceleracion = deceleracion
self._velocidad_maxima = velocidad_maxima
self._aceleracion = aceleracion
self.con_rotacion = con_rotacion
self.velocidad_rotacion = velocidad_rotacion
self.marcha_atras = marcha_atras
def actualizar(self):
self.avanzar_animacion()
vx = 0
if pilas.escena_actual().control.izquierda:
vx = -(self.receptor.velocidad)
self.receptor.espejado = True
self.receptor.habilidades.Disparar.angulo_salida_disparo = 90
self.receptor.obtener_colisiones()
if not (self.receptor.colisiona_arriba_izquierda
or self.receptor.colisiona_abajo_izquierda):
self.receptor.x += vx
elif pilas.escena_actual().control.derecha:
vx = self.receptor.velocidad
self.receptor.espejado = False
self.receptor.habilidades.Disparar.angulo_salida_disparo = -90
self.receptor.obtener_colisiones()
if not (self.receptor.colisiona_arriba_derecha
or self.receptor.colisiona_abajo_derecha):
self.receptor.x += vx
else:
self.receptor.hacer(Esperando())
if pilas.escena_actual().control.arriba:
self.receptor.hacer(Saltando(-8))
self.caer_si_no_toca_el_suelo()
def actualizar(self):
self.avanzar_animacion()
dx = 0
dy = 0
if pilas.escena_actual().control.izquierda:
dx = self.receptor.velocidad * -1
self.receptor.direccion = pilas.actores.personajes_rpg.OESTE
elif pilas.escena_actual().control.derecha:
dx = self.receptor.velocidad
self.receptor.direccion = pilas.actores.personajes_rpg.ESTE
elif pilas.escena_actual().control.arriba:
dy = self.receptor.velocidad
self.receptor.direccion = pilas.actores.personajes_rpg.NORTE
elif pilas.escena_actual().control.abajo:
dy = self.receptor.velocidad * -1
self.receptor.direccion = pilas.actores.personajes_rpg.SUR
else:
self.receptor.hacer(Esperando())
if not (self.receptor.mapa.es_punto_solido(self.receptor.x + dx,
self.receptor.y + dy)):
self.receptor.x += dx
self.receptor.y += dy
def _realizarGiro(self, vel, seconds):
def izquierdaSinTiempo():
self.actor.hacer(pilas.comportamientos.Girar(-abs(self.actor.velocidad), self.actor.velocidad))
return (self.movimiento)
def derechaSinTiempo():
self.actor.hacer(pilas.comportamientos.Girar(abs(self.actor.velocidad), self.actor.velocidad))
return (self.movimiento)
self.stop()
self._setVelocidad(vel)
if (self._velocidadValida(vel, 10, 100)) :
self.movimiento = True
self.tarea = pilas.escena_actual().tareas.condicional(0.1, derechaSinTiempo)
if (seconds != -1):
wait(seconds)
self.stop()
elif (self._velocidadValida(vel, -100, -10)) :
self.movimiento = True
self.tarea = pilas.escena_actual().tareas.condicional(0.1, izquierdaSinTiempo)
self.actor.velocidad = self.actor.velocidad * -1
if (seconds != -1):
wait(seconds)
self.stop()
else:
print """ Rangos de velocidades válidas:
def insertar_como_nuevo_actor(actor):
"""Coloca a un actor en la lista de actores a imprimir en pantalla.
:param actor: Actor que se quiere comenzar a mostrar en pantalla.
"""
pilas.escena_actual().actores.append(actor)
actor.escena = pilas.escena_actual()
def insertar_como_nuevo_actor(actor):
"""Coloca a un actor en la lista de actores a imprimir en pantalla.
:param actor: Actor que se quiere comenzar a mostrar en pantalla.
"""
pilas.escena_actual().actores.append(actor)
actor.escena = pilas.escena_actual()
def cuando_colisionan(autobueno,autito):
for i in range(len(self.autitosmalos)):
self.autitosmalos[i].eliminar()
autobueno.eliminar()
pilas.escena_actual().tareas.eliminar_todas()
Fondo= pilas.imagenes.cargar("personajes/autos.jpg")
fondo_perdedor= pilas.fondos.Fondo(Fondo)
texto3=pilas.actores.Texto("Tu ultimo puntaje es : " + self.puntaje.obtener_texto())
texto3.y=70
texto3.color = pilas.colores.verde
textoo=pilas.actores.Texto("Termino el juego mas suerte para la proxima ")
textoo.y=130
textoo.color = pilas.colores.amarillo
#___________________________________menu de colision_____________________________________________#
def iniciar_juego_de_nuevo(): #Inicia de nuevo el juego
pilas.cambiar_escena(EscenaDeJuego())
def volver_menu(): #Vuelve al menu principal
pilas.mundo.motor.mostrar_puntero_del_mouse()
pilas.cambiar_escena(EscenaDeMenu())
def salir_del_juego(): #sale del juego
pilas.terminar()
def guarda_puntaje():
pilas.mundo.motor.mostrar_puntero_del_mouse()
puntaje = self.puntaje.obtener_texto()
pilas.cambiar_escena(GuardarPuntaje(puntaje))
menu = pilas.actores.Menu([("Reiniciar juego", iniciar_juego_de_nuevo),
("Volver al menu principal", volver_menu),
("Guardar puntaje", guarda_puntaje),
("Salir", salir_del_juego),
])
def actualizar(self): self.avanzar_animacion() vx = 0 if pilas.escena_actual().control.izquierda: vx = -(self.receptor.velocidad) if not self.receptor.espejado: self.receptor.espejado = True #self.receptor.x -= VELOCIDAD self.receptor.obtener_colisiones() if not(self.receptor.colisiona_arriba_izquierda or self.receptor.colisiona_abajo_izquierda): self.receptor.x += vx elif pilas.escena_actual().control.derecha: vx = self.receptor.velocidad if self.receptor.espejado: self.receptor.espejado = False #self.receptor.x += VELOCIDAD self.receptor.obtener_colisiones() if not(self.receptor.colisiona_arriba_derecha or self.receptor.colisiona_abajo_derecha): self.receptor.x +=vx else: self.receptor.hacer(Esperando()) if pilas.escena_actual().control.arriba: self.receptor.hacer(Saltando(-9)) self.caer_si_no_toca_el_suelo()
def destruir(self):
"""Elimina a un actor pero de manera inmediata."""
self._vivo = False
self.eliminar_habilidades()
self.eliminar_comportamientos()
# Solo permite eliminar el actor si está en su escena.
if self in pilas.escena_actual().actores:
pilas.escena_actual().actores.remove(self)
def actualizar(self):
if pilas.escena_actual().control.izquierda:
self.receptor.hacer(Caminando())
elif pilas.escena_actual().control.derecha:
self.receptor.hacer(Caminando())
if pilas.escena_actual().control.arriba:
self.receptor.hacer(Saltando())
def __init__(self, receptor, lado_seguimiento=ARRIBA):
Habilidad.__init__(self, receptor)
pilas.escena_actual().mueve_mouse.conectar(self.se_movio_el_mouse)
pilas.escena_actual().actualizar.conectar(self.rotar)
self.lado_seguimiento = lado_seguimiento
self.raton_x = receptor.x
self.raton_y = receptor.y
def perder(torreta, enemigo):
global fin_de_juego
enemigo.sonreir()
torreta.eliminar()
pilas.escena_actual().tareas.eliminar_todas()
fin_de_juego = True
pilas.avisar("GAME OVER. Conseguiste %d puntos" %(puntos.obtener()))
def __init__(self, receptor, lado_seguimiento=ARRIBA):
Habilidad.__init__(self, receptor)
pilas.escena_actual().mueve_mouse.conectar(self.se_movio_el_mouse)
pilas.escena_actual().actualizar.conectar(self.rotar)
self.lado_seguimiento = lado_seguimiento
self.raton_x = receptor.x
self.raton_y = receptor.y
def eliminar_a_todos():
"""Elimina a todos los actores de la escena."""
a_eliminar = pilas.escena_actual().actores[1:] # evita borrar el fondo.
for x in a_eliminar:
x.eliminar()
pilas.escena_actual().actores = []
def destruir_a_todos():
"""Elimina a los actores inmediatamente (evita que exploten o hagan algo)."""
a_eliminar = pilas.escena_actual().actores
for x in a_eliminar:
x.destruir()
pilas.escena_actual().actores = []
def destruir(self):
"""Elimina a un actor pero de manera inmediata."""
self._vivo = False
self.eliminar_habilidades()
self.eliminar_comportamientos()
# Solo permite eliminar el actor si está en su escena.
if self in pilas.escena_actual().actores:
pilas.escena_actual().actores.remove(self)
def plantar_bomba(self):
if self.tiene_bomba:
bomba = pilas.actores.Bomba(x=self.x, y=self.y)
bomba.escala = 0.5
self.tiene_bomba = False
pilas.escena_actual().colisiones.agregar(self.enemigo, bomba, self.destruir_enemigo)
def actualizar(self):
if pilas.escena_actual().control.izquierda:
self.receptor.hacer(Caminando())
elif pilas.escena_actual().control.derecha:
self.receptor.hacer(Caminando())
if pilas.escena_actual().control.arriba:
self.receptor.hacer(Saltando())
def perder(torreta, enemigo):
global fin_de_juego
enemigo.sonreir()
torreta.eliminar()
pilas.escena_actual().tareas.eliminar_todas()
fin_de_juego = True
pilas.avisar("GAME OVER. Conseguiste %d puntos" % (puntos.obtener()))
def destruir_a_todos():
"Elimina a los actores inmediatamente (evita que exploten o hagan algo)."
a_eliminar = pilas.escena_actual().actores
for x in a_eliminar:
x.destruir()
pilas.escena_actual().actores = []
def dibuja_al_actor(self, motor, painter, lienzo, actor):
if not isinstance(actor, pilas.fondos.Fondo):
texto = "(%d, %d)" % (actor.x, actor.y)
lienzo.texto(painter,
texto,
actor.derecha - pilas.escena_actual().camara.x,
actor.abajo - pilas.escena_actual().camara.y,
color=pilas.colores.violeta)
def crear_enemigo():
enemigo = pilas.actores.Mono()
x = random.randrange(-320, 320)
y = random.randrange(-240, 240)
# Hace que la aceituna aparezca gradualmente, aumentando de tamaño.
enemigo.escala = 0
enemigo.escala = pilas.interpolar(0.5, duracion=0.5, tipo='elastico_final')
enemigo.aprender(pilas.habilidades.PuedeExplotar)
if x >= 0 and x <= 100:
x = 180
elif x <= 0 and x >= -100:
x = -180
if y >= 0 and y <= 100:
y = 180
elif y <= 0 and y >= -100:
y = -180
enemigo.x = x
enemigo.y = y
enemigos.append(enemigo)
tipo_interpolacion = [
'lineal', 'aceleracion_gradual', 'desaceleracion_gradual',
'rebote_inicial', 'rebote_final'
]
enemigo.x = pilas.interpolar(0,
tiempo,
tipo=random.choice(tipo_interpolacion))
enemigo.y = pilas.interpolar(0,
tiempo,
tipo=random.choice(tipo_interpolacion))
if random.randrange(0, 20) > 15:
if issubclass(torreta.habilidades.DispararConClick.municion,
municion_bala_simple):
estrella = pilas.actores.Estrella(x, y)
estrella.escala = pilas.interpolar(0.5,
duracion=0.5,
tipo='elastico_final')
pilas.escena_actual().colisiones.agregar(
estrella, torreta.habilidades.DispararConClick.proyectiles,
asignar_arma_doble)
pilas.mundo.agregar_tarea(3, eliminar_estrella, estrella)
if fin_de_juego:
return False
else:
return True
