Hola @jemf !!!
Arreglé la mayoría de los problemas que encontré, tuve que poner “#” al principio de varias lineas porque no tenía las imágenes del juego, mirá el código y eliminá esos “#” según corresponda:
El código tiene muchos detalles para corregir, pero son muchísimos… no puedo verlos todos, igualmente los arreglos que hice te van a servir. Avisanos cualquier cosa.
# coding: utf-8
import pilasengine
from pilasengine.actores.actor import Actor
from pilasengine.comportamientos.comportamiento import Comportamiento
import random
pilas = pilasengine.iniciar(ancho = 1280, alto = 700)
class EscenaMenu(pilasengine.escenas.Escena):
def iniciar(self):
fondo = pilas.fondos.Fondo()
#fondo.imagen = pilas.imagenes.cargar("/home/jemf/Escritorio/Proyecto Juego/fondos/fondo2.jpg")
fondo.imagen = pilas.imagenes.cargar("mono.png")
self.Mi_Menu = pilas.actores.Menu(
[
(u'IR AL JUEGO', self.Ir_al_juego),
(u'HISTORIA DEL JUEGO' , self.Historia_del_juego),
(u'SALIR DE PILAS', self.Salir_de_Pilas)
])
##############################################
Nombre_de_mi_juego = pilas.actores.Texto(u'VENGANZA')
Nombre_de_mi_juego.color = pilas.colores.blanco
Nombre_de_mi_juego.y = 170
def Salir_de_Pilas(self):
pilas.terminar()
def Ir_al_juego(self):
pilas.escenas.EscenaJuego()
def Historia_del_juego(self):
pilas.escenas.HistoriaJuego()
class EscenaJuego(pilasengine.escenas.Escena):
def iniciar(self):
pilas.escenas.Normal()
#fondo = pilas.fondos.Fondo("/home/jemf/Escritorio/juego/fondos/conjuro.png")
fondo = pilas.fondos.Fondo()
self.lista_enemigos = []
self.cantidad_de_enemigos = 0
self._crear_barras_de_energia()
#self.stickman = self.pilas.actores.Stickman(self.lista_enemigos, self)
#self.stickman = pilas.actores.Stickman(y = -100 , x = 200 , imagen = "/home/jemf/Escritorio/juego/sprites/stickman/stickman.png" )
self.stickman = pilas.actores.Stickman(y = -100 , x = 200 , imagen="aceituna.png")
self.stickman.escala = 0.5
teclas = {
pilas.simbolos.a: 'izquierda',
pilas.simbolos.d: 'derecha' ,
pilas.simbolos.w: 'arriba' ,
pilas.simbolos.g: 'boton' ,
pilas.simbolos.h: 'boton2'}
mi_control = pilas.control.Control(teclas)
self._crear_eventos_personalizados()
self._crear_escenario()
def _crear_eventos_personalizados(self):
pilas.eventos.se_golpea_a_enemigo = pilas.evento.Evento("se_golpea_enemigo")
pilas.eventos.se_golpea_a_enemigo.conectar(self.actualizar_energia_enemigo)
pilas.eventos.se_golpea_a_stickman = pilas.evento.Evento("se_golpea_a_stickman")
pilas.eventos.se_golpea_a_stickman.conectar(self.actualizar_energia_stickman)
pilas.eventos.se_muere_un_enemigo = pilas.evento.Evento("se_muere_un_enemigo")
pilas.eventos.se_muere_un_enemigo.conectar(self._cuando_muere_un_enemigo)
pilas.eventos.se_muere_el_stickman = pilas.evento.Evento("se_muere_el_stickman")
pilas.eventos.se_muere_el_stickman.conectar(self._cuando_muere_el_stickman)
def _crear_escenario(self):
#escenario.Escenario(self)
pass
def crear_enemigo(self, clase, x, y):
self.lista_enemigos.append(clase(self.stickman, x=x, y=y))
self.cantidad_de_enemigos += 1
def _cuando_muere_un_enemigo(self, evento):
#actor_que_muere = evento.actor
self.cantidad_de_enemigos -= 1
def _cuando_muere_el_stickman(self, evento):
#referencia_al_shaolin_que_muere = evento.actor
self._crear_texto_game_over()
pilas,eventos.pulsa_tecla_escape.conectar(self._reiniciar_el_nivel)
def _reiniciar_el_nivel(self, evento):
self.pilas.escenas.EscenaJuego()
def _crear_texto_game_over(self):
titulo = "Game Over"
subtitulo = "Pulse escape para reiniciar"
self._crear_mensaje_de_texto(subtitulo, titulo)
def _crear_mensaje_de_texto(self, subtitulo, titulo):
texto_titulo = pilas.actores.Texto(titulo, magnitud=40)
texto_titulo.z = -1000
texto_titulo.escala = 0.1
texto_titulo.escala = [1], 0.5
texto_subtitulo = pilas.actores.Texto(subtitulo)
texto_subtitulo.y = -60
texto_subtitulo.transparencia = 100
texto_subtitulo.transparencia = [0]
texto_subtitulo.z = -1000
def _crear_barras_de_energia(self):
self.energia_stickman = pilas.actores.Energia(x=-280, y=213, alto=20)
self.energia_enemigo = pilas.actores.Energia(x=+315, y=213, alto=20)
def actualizar_energia_enemigo(self, evento):
self.energia_enemigo.progreso = evento.quien.energia
def actualizar_energia_stickman(self, evento):
self.energia_stickman.progreso = evento.quien.energia
def Volver(self):
pilas.escenas.EscenaMenu()
def actualizar(self):
pass
class HistoriaJuego(pilasengine.escenas.Escena):
def iniciar(self):
#self.musicainter = self.pilas.musica.cargar("musica_fondo/Chaos Chaos - Do You Feel It (RICK AND MORTY).mp3")
#self.musicainter.reproducir()
#fondo = pilas.fondos.Fondo()
#fondo.imagen = pilas.imagenes.cargar("/home/jemf/Escritorio/juego/fondos/negro.jpg")
self.Expli = self.pilas.actores.Texto("""
el es el hijo de un casador de demonios y busca venganza de parte de su padre\n
ya que satanas se lo ah llevado a las profundidades del infierno\n
ahora el esta combatiendo con un ejercito demoniaco galactico espacial\n
""")
self.Expli.y = -450
self.Expli.x = 0
self.bajar_texto()
self.pilas.tareas.agregar(5, self.crear_menu)
def bajar_texto(self):
self.pilas.utils.interpolar(self.Expli, 'y', 500, duracion=40, tipo='lineal')
def crear_menu(self):
self.MiMenu6 = self.pilas.actores.Menu([
(u'Volver a menu...', self.volver_a_ver),
])
def volver_a_ver(self):
self.pilas.escenas.EscenaMenu()
class Stickman(pilasengine.actores.Actor):
def iniciar(self, x=0, y=0, imagen=None, imagen2=None, control=None):
self.x = x
self.y = y
if control:
self.control = control
else:
self.control = self.pilas.control
if imagen:
self.path_img = imagen
elif imagen:
self.imagen ="/home/jemf/Escritorio/juego/sprites/stickman/stickman.png"
if imagen2:
self.path_img2 = imagen2
elif imagen2:
self.path_img2 = "/home/jemf/Escritorio/juego/sprites/stickman/corre.png"
self.hacer_inmediatamente(Parado)
self.altura_del_salto = 0
#def cuando_pulsa_una_tecla(self, evento):
#elif evento.codigo == pilas.simbolos.d:
#self.comportamiento_actual.pulsa_golpear()
class Parado(Comportamiento):
def iniciar(self, receptor):
self.receptor = receptor
self.control = receptor.control
self.receptor.imagen = self.pilas.imagenes.cargar_grilla(self.receptor.path_img)
self.receptor.centro = ("centro", "abajo")
def actualizar(self):
self.receptor.imagen.avanzar(10)
if self.control.derecha or self.control.izquierda:
self.receptor.hacer_inmediatamente(Caminar)
if self.control.arriba:
self.receptor.hacer_inmediatamente(Saltar)
if self.control.boton:
self.receptor.hacer_inmediatamente(Pegar)
if self.control.boton2:
self.receptor.hacer_inmediatamente(Patada)
class Caminar(Comportamiento):
def iniciar(self, receptor):
self.receptor = receptor
self.control = receptor.control
self.receptor.imagen = self.pilas.imagenes.cargar_grilla(self.receptor.path_img2, 4, 1)
self.receptor.centro = ("centro", "abajo")
def actualizar(self):
self.receptor.imagen.avanzar(10)
# Si pulsa a los costados se puede mover.
if self.control.derecha:
self.receptor.x += 5
self.receptor.espejado = False
elif self.control.izquierda:
self.receptor.x -= 5
self.receptor.espejado = True
# Si pulsa hacia arriba salta.
if self.control.arriba:
self.receptor.hacer_inmediatamente(Saltar)
if self.control.boton:
self.receptor.hacer_inmediatamente(Pegar)
if self.control.boton2:
self.receptor.hacer_inmediatamente(Pegar)
# Si suelta las teclas regresa al estado inicial.
if not self.control.derecha and not self.control.izquierda:
self.receptor.hacer_inmediatamente(Parado)
class Saltar(Comportamiento):
def iniciar(self, receptor):
self.receptor = receptor
self.control = receptor.pilas.control
self.receptor.imagen = self.pilas.imagenes.cargar_grilla("/home/jemf/Escritorio/Proyecto Juego/sprites/stickman/salto.png", 3, 1)
self.receptor.centro = ("centro", "abajo")
self.y_inicial = self.receptor.y
self.vy = 15
def actualizar(self):
self.receptor.y += self.vy
self.vy -= 0.7
distancia_al_suelo = self.receptor.y - self.y_inicial
self.receptor.altura_del_salto = distancia_al_suelo
# Cuando llega al suelo, regresa al estado inicial.
if distancia_al_suelo < 0:
self.receptor.y = self.y_inicial
self.receptor.altura_del_salto = 0
self.receptor.hacer_inmediatamente(Parado)
# Si pulsa a los costados se puede mover.
if self.control.derecha:
self.receptor.x += 5
self.receptor.espejado = False
elif self.control.izquierda:
self.receptor.x -= 5
self.receptor.espejado = True
class Golpear (Comportamiento):
ha_golpeado = False
numero_de_ataque = 0
def iniciar(self, receptor):
self.receptor = receptor
self.control = receptor.pilas.control
if evento.codigo == pilas.simbolos.boton:
self.receptor.imagen = self.pilas.imagenes.cargar_grilla("/home/jemf/Escritorio/Proyecto Juego/sprites/stickman/puno.png", 3, 1)
self.receptor.centro = ("centro", "abajo")
def actualizar(self):
if self.receptor.avanzar_animacion(0.4):
self.receptor.hacer(Parado())
self.eliminar_golpe()
else:
if self.golpe:
enemigo = self.golpe.verificar_colisiones()
if enemigo:
self.eliminar_golpe()
ataque_fuerte = (self.numero_de_ataque == 4)
enemigo.ha_sido_golpeado(self.shaolin, fuerte=ataque_fuerte)
Golpear.ha_golpeado = True
else:
Golpear.ha_golpeado =False
def ha_sido_golpeado(self, otro_actor, fuerte):
self._pasa_a_estado_golpeado()
def __init__(self, actor, enemigos, dx, dy):
pilas.actores.Actor.__init__(self)
self.actor = actor
self.dx = dx
self.dy = dy
self.enemigos = enemigos
self.actualizar()
def actualizar(self):
if self.actor.espejado:
self.x = self.actor.x - 70 - self.dx
else:
self.x = self.actor.x + 70 + self.dx
self.y = self.actor.y + self.actor.altura_del_salto + self.dy
def verificar_colisiones(self):
for enemigo in self.enemigos:
area = [
enemigo.izquierda + 10,
enemigo.derecha - 10,
enemigo.abajo,
enemigo.arriba,
]
if enemigo.puede_ser_golpeado:
if area[0] < self.x < area[1] and area[2] < self.y < area[3]:
if abs(enemigo.y - self.actor.y) < 15:
if enemigo.altura_del_salto < 80:
self.crear_efecto_de_golpe()
return enemigo
def crear_efecto_de_golpe(self):
dx = random.randint(-10, 10)
dy = random.randint(-10, 10)
efecto_golpe.EfectoGolpe(self.x + dx, self.y + dy)
class Patada (Comportamiento):
ha_golpeado = False
numero_de_ataque = 0
def iniciar(self, receptor):
self.receptor = receptor
self.control = receptor.pilas.control
if evento.codigo == pilas.simbolos.boton2:
self.receptor.imagen = self.pilas.imagenes.cargar_grilla("/home/jemf/Escritorio/Proyecto Juego/sprites/stickman/patada.png", 3, 1)
self.receptor.centro = ("centro", "abajo")
def actualizar(self):
if self.receptor.avanzar_animacion(0.4):
self.receptor.hacer(Parado())
self.eliminar_golpe()
else:
if self.golpe:
enemigo = self.golpe.verificar_colisiones()
if enemigo:
self.eliminar_golpe()
ataque_fuerte = (self.numero_de_ataque == 4)
enemigo.ha_sido_golpeado(self.shaolin, fuerte=ataque_fuerte)
Golpear.ha_golpeado = True
else:
Golpear.ha_golpeado =False
def ha_sido_golpeado(self, otro_actor, fuerte):
self._pasa_a_estado_golpeado()
def __init__(self, actor, enemigos, dx, dy):
pilas.actores.Actor.__init__(self)
self.actor = actor
self.dx = dx
self.dy = dy
self.enemigos = enemigos
self.actualizar()
def actualizar(self):
if self.actor.espejado:
self.x = self.actor.x - 70 - self.dx
else:
self.x = self.actor.x + 70 + self.dx
self.y = self.actor.y + self.actor.altura_del_salto + self.dy
def verificar_colisiones(self):
for enemigo in self.enemigos:
area = [
enemigo.izquierda + 10,
enemigo.derecha - 10,
enemigo.abajo,
enemigo.arriba,
]
if enemigo.puede_ser_golpeado:
if area[0] < self.x < area[1] and area[2] < self.y < area[3]:
if abs(enemigo.y - self.actor.y) < 15:
if enemigo.altura_del_salto < 80:
self.crear_efecto_de_golpe()
return enemigo
def dibujar(self, aplicacion):
if DEPURACION:
pilas.actores.Actor.dibujar(self, aplicacion)
def crear_efecto_de_golpe(self):
dx = random.randint(-10, 10)
dy = random.randint(-10, 10)
efecto_golpe.EfectoGolpe(self.x + dx, self.y + dy)
class Enemigos(pilasengine.actores.Actor):
def __init__(self, Stickman, x, y):
enemigo.Enemigo.__init__(self)
self.Stickman = Stickman
self._cargar_animaciones()
self.z = 0
self.centro = ("centro", "abajo")
self.x = x
self.y = y
self.altura_del_salto = 0
self.actualizar()
self._iniciar()
self.pasar_al_siguiente_estado_ai()
self.mover(0, 0)
self.energia = 100
def reducir_energia(self, cantidad):
self.energia -= cantidad
pilas.eventos.se_golpea_a_enemigo.emitir(quien=self)
def _iniciar(self):
self.comportamientos_ai = [
estados.Parado(segundos=1),
estados.CaminarAleatoriamente(segundos=0.5),
estados.Golpear(),
estados.Parado(segundos=1),
estados.CaminaHaciaLineaVerticalDelStickman(segundos=1),
]
self.comportamiento_ai_indice = 0
self.hacer(estados.IngresarCayendo())
self.miniatura = pilas.imagenes.cargar("red/mini.png")
def actualizar(self):
enemigo.Enemigo.actualizar(self)
if self.avanzar_animacion(0.15):
self.comportamiento_actual.ha_terminado_animacion()
def pasar_al_siguiente_estado_ai(self):
self.comportamiento_ai_indice += 1
self.comportamiento_ai_indice %= len(self.comportamientos_ai)
estado_nuevo = self.comportamientos_ai[self.comportamiento_ai_indice]
self.hacer(estado_nuevo)
def cargar_primer_estado_ai(self):
self.comportamiento_ai_indice = -1
self.pasar_al_siguiente_estado_ai()
def _cargar_animaciones(self):
cargar = pilas.imagenes.cargar_grilla
self.animaciones = {
'parado': cargar("/home/jemf/Escritorio/juego/sprites/enemigo.png", 1),
'golpear': cargar("/home/jemf/Escritorio/juego/sprites/enemigos/puno.png", 3),
'patada' : cargar("/home/jemf/Escritorio/juego/sprites/enemigos/patada.png", 3),
'caminar': cargar("/home/jemf/Escritorio/juego/sprites/enemigos/corre.png", 4),
'saltando': cargar("/home/jemf/Escritorio/juego/sprites/enemigos/salto.png", 1),
}
def mirar_al_stickman(self):
self.espejado = self.stickman.x < self.x
class Parado(Comportamiento):
def iniciar(self, enemigo):
Comportamiento.iniciar(self, enemigo)
self.enemigo.cambiar_animacion('parado')
self.enemigo.mirar_al_stickman()
def actualizar(self):
Comportamiento.actualizar(self)
self.enemigo.mirar_al_stickman()
class CaminarAleatoriamente(Comportamiento):
def iniciar(self, enemigo):
Comportamiento.iniciar(self, enemigo)
self.enemigo.cambiar_animacion('caminar')
self.dx = random.choice([1, -1])
self.dy = random.choice([1, 0, -1])
def actualizar(self):
Comportamiento.actualizar(self)
self.enemigo.mover(self.dx, self.dy)
self.enemigo.mirar_al_stic()
class Golpear(Comportamiento):
def iniciar(self, enemigo):
Comportamiento.iniciar(self, enemigo)
self.enemigo.cambiar_animacion('golpear')
self.golpear(dx=30)
def actualizar(self):
Comportamiento.actualizar(self)
if self.golpe:
stickman_que_ha_golpeado = self.golpe.verificar_colisiones()
if stickman_que_ha_golpeado:
stickman_que_ha_golpeado.ha_sido_golpeado(self, False)
self.eliminar_golpe()
def ha_terminado_animacion(self):
self.eliminar_golpe()
self.enemigo.pasar_al_siguiente_estado_ai()
class LoGolpean(Comportamiento):
def iniciar(self, enemigo):
Comportamiento.iniciar(self, enemigo)
self.enemigo.cambiar_animacion('lo_golpean')
self.x_inicial = self.enemigo.x
self.y_inicial = self.enemigo.y
self.contador = 20
enemigo.reducir_energia(15)
def actualizar(self):
x = self.x_inicial
y = self.y_inicial
self.enemigo.x = random.choice([x - 1, x, x + 1])
self.enemigo.y = random.choice([y - 1, y, y + 1])
if self.contador < 0:
self.enemigo.x = self.x_inicial
self.enemigo.y = self.y_inicial
self.enemigo.cargar_primer_estado_ai()
else:
self.contador -= 1
def ha_sido_golpeado(self, otro_actor, fuerte=False):
pass
class CaminaHaciaLineaVerticalDelStickman(Comportamiento):
def iniciar(self, enemigo):
Comportamiento.iniciar(self, enemigo)
self.enemigo.cambiar_animacion('caminar')
self._seleccionar_dy()
self._salir_si_esta_cerca_verticalmente()
def actualizar(self):
Comportamiento.actualizar(self)
self.enemigo.mover(0, self.dy)
self.enemigo.mirar_al_stickman()
self._salir_si_esta_cerca_verticalmente()
def _distancia_vertical_al_shaolin(self):
return abs(self.enemigo.stickman.y - self.enemigo.y)
def _salir_si_esta_cerca_verticalmente(self):
if self._distancia_vertical_al_stickman() < 10:
self.enemigo.pasar_al_siguiente_estado_ai()
def _seleccionar_dy(self):
if self.enemigo.stickman.y < self.enemigo.y:
self.dy = -1
else:
self.dy = 1
class Morirse(Comportamiento):
def iniciar(self, enemigo):
Comportamiento.iniciar(self, enemigo)
self.enemigo.definir_cuadro(1)
self.enemigo.puede_ser_golpeado = False
pilas.eventos.se_muere_un_enemigo.emitir(actor=self)
def actualizar(self):
Comportamiento.actualizar(self)
self.enemigo.definir_cuadro(1)
self.enemigo.transparencia += 1
self.enemigo.sombra.transparencia += 1
if self.enemigo.transparencia > 100:
self.eliminar_actor_del_escenario()
def eliminar_actor_del_escenario(self):
self.enemigo.sombra.eliminar()
self.enemigo.eliminar()
pilas.escenas.vincular(EscenaMenu)
pilas.escenas.EscenaMenu()
pilas.escenas.vincular(EscenaJuego)
pilas.escenas.vincular(HistoriaJuego)
pilas.actores.vincular(Stickman)
pilas.actores.vincular(Enemigos)
pilas.ejecutar()
eh tenido un pequeño problema con una parte del juego que me dice :
