Error de colison

[lucas1]

hola queria saber xq no me agarra para colisonar entre la vida y el heroe y como puedo hacer para que cuando toca al heroe sume la vida de este .El error es que me dice que heroe no esta definido
NameError:name heroe is not defined

# coding: utf-8
import pilasengine
pilas = pilasengine.iniciar()

#Variables GLOBALES
cantidad_puntos = 0
cantidad_vida = 3
cantidad_vidajefe = 200

#Funciones del menú:
def iniciar_juego():
    pilas.escenas.EscenaJuego() 
def salir_del_juego():
    pilas.terminar()
def instrucciones_del_juego():
    pilas.escenas.instrucciones()
    
def creditos_del_juego():
    pilas.escenas.creditos()

#Clase que corresponde a la PRIMERA ESCENA, que contiene un menú: 
class AntiHeroe(pilasengine.actores.Actor):
    def iniciar(self):
        self.imagen=pilas.imagenes.cargar("C:\omarpilas\imagenes\wh.png")
        self.escala_x=0.9
        self.escala_y=0.7
        #self.x=0
        self.y=300                  
        self.y=[100],3
        hitbox=pilas.fisica.Rectangulo(0,300,350,300,dinamica=False)
        self.figura_de_colision = hitbox
        
pilas.actores.vincular(AntiHeroe)


class creditos (pilasengine.escenas.Escena):
    def iniciar(self):
        self.f = pilas.fondos.Fondo()
        self.f.imagen = pilas.imagenes.cargar("C:\omarpilas\imagenes\creditos.jpg")
        self.f.escala=1.3
pilas.escenas.vincular(creditos)

class instrucciones (pilasengine.escenas.Escena):
    def iniciar(self):
        self.f = pilas.fondos.Fondo()
        self.f.imagen = pilas.imagenes.cargar("C:\omarpilas\imagenes\wespacio.png")
        self.f.escala=0.8
pilas.escenas.vincular(instrucciones)

class EscenaMenu(pilasengine.escenas.Escena):
    def iniciar(self):
        self.f = pilas.fondos.Fondo()
        self.f.escala_x =-200
        self.f.escala_y = 30
        self.f.escala= 0.8
        self.f.imagen = pilas.imagenes.cargar("C:\omarpilas\imagenes\wSpringfield.png")
        self.lista_de_opciones = pilas.actores.Menu([
            ("Jugar", iniciar_juego),
            ("Salir", salir_del_juego),
            ("instrucciones" , instrucciones_del_juego),
            ("creditos" , creditos_del_juego)
            
        ])
        texto_titulo = pilas.actores.Texto("the simpson")
        texto_titulo.x = [150,-150,0],0.5
        texto_titulo.y = 200
        texto_titulo.escala = [1.5,0.2,4],1

#Vinculo la escena
pilas.escenas.vincular(EscenaMenu)

class EscenaJuego(pilasengine.escenas.Escena):
    def iniciar(self):
        cantidad_puntos = 0;
        #pilas.forzar_habilitacion_de_audio()
        #fondo personalizado
        self.f = pilas.fondos.Fondo()
        self.f.imagen = pilas.imagenes.cargar("C:\omarpilas\imagenes\wwSpringfield.png")
        #tarea que crea enemigos siempre :v
        pilas.tareas.siempre(2, funcionCreandoEnemigos)
        pilas.tareas.siempre(2, funcionCreandoEnemigoos)
        
        jake = pilas.actores.Heroe()
        
        pilas.colisiones.agregar(jake, miGrupoRigbyy, colisionMeMueroo)
        pilas.tareas.siempre(0.8,funcionCreandoVidaaaa)
        pilas.colisiones.agregar('Enemigo','miMunicion', colisionDisparo)
         
    
            
         #Puntaje:
        self.score = pilas.actores.Puntaje(x=-180,y=200,color=pilas.colores.blanco)
        self.score.definir(cantidad_puntos)
        #self.score.escala = 5
        self.texto_puntaje = pilas.actores.Texto("Puntitos:", x=-250, y=200)
        self.texto_puntaje.color = pilas.colores.blanco
        pilas.colisiones.agregar('Enemigo','miMunicion', self.sumar_puntos)
        
        #VIDA:
        self.puntos_de_vida = pilas.actores.Puntaje(x=200,y=200,color=pilas.colores.blanco)
        self.puntos_de_vida.definir(cantidad_vida)
        self.texto_vida = pilas.actores.Texto("Vida:", x=150,y=200)
        self.texto_vida.color = pilas.colores.blanco
        pilas.colisiones.agregar(jake, miGrupoRigby, self.restar_vidas)

    def restar_vidas(self):
        global cantidad_vida
        cantidad_vida -= 1
        self.puntos_de_vida.aumentar(-1)
        if cantidad_vida <=0:
            pilas.escenas.EscenaPerdiste();
            cantidad_vida = 3;
    
    def sumar_puntos(self):
        global cantidad_puntos
        self.score.aumentar(1)
        cantidad_puntos += 1
        if (cantidad_puntos >=1):
            pilas.escenas.nivel2 ();
            cantidad_puntos = 0;

#VINCULAR LA ESCENA DE JUEGO:
pilas.escenas.vincular(EscenaJuego)

class EscenaPerdiste(pilasengine.escenas.Escena):
    def iniciar(self):
        self.f = pilas.fondos.Fondo()
        self.f.y = 30
        self.f.escala= 1.2
        self.f.imagen = pilas.imagenes.cargar("C:\omarpilas\imagenes\homerooo.jpg")
        self.f.escala_x=2
        self.f.escala_y=1.5
        self.textito = pilas.actores.Texto("perdiste")
        self.textito.x=0
        self.textito.y=100
        btn_volver = pilas.interfaz.Boton("VOLVER")
        btn_volver.conectar(funcionVolverMenu)
pilas.escenas.vincular(EscenaPerdiste)

def funcionVolverMenu():
    pilas.escenas.EscenaMenu()
 

class EscenaGanaste(pilasengine.escenas.Escena):
    def iniciar(self):
        self.f = pilas.fondos.Fondo()
        self.f.y = 30
        self.f.escala= 1.2
        self.f.imagen = pilas.imagenes.cargar("C:\omarpilas\imagenes\whomero.png")
        self.f.escala_x=1
        self.f.escala_y=0.6
        btn_volver = pilas.interfaz.Boton("VOLVER")
        btn_volver.conectar(funcionVolverMenu)
        texto_titulo = pilas.actores.Texto("Ganaste")
        texto_titulo.y = 200

#Vinculo la escena
pilas.escenas.vincular(EscenaGanaste)

#Grupo de enemigos :)
miGrupoRigby = pilas.actores.Grupo()
#Función para crear enemigos y agregarlos al grupo
def funcionCreandoEnemigos():
    enemigo = pilas.actores.Enemigo()
    miGrupoRigby.agregar(enemigo)

class miMunicion(pilasengine.actores.Actor):
    def iniciar(self):
        self.imagen = pilas.imagenes.cargar_grilla("C:\omarpilas\imagenes\wfuego.png",4)
        self.cuadro = 0
pilas.actores.vincular(miMunicion)

#Creando nuestra clase heroe
class Heroe(pilasengine.actores.Actor):
    def iniciar(self):
        self.imagen = pilas.imagenes.cargar("C:\omarpilas\imagenes\www.png");
        self.escala=0.1
        self.vida = 3
        self.cuadro=0
        self.aprender(pilas.habilidades.SeMantieneEnPantalla)
        self.aprender(pilas.habilidades.Disparar, offset_origen_actor=(0,20), escala=0.5, municion='miMunicion', angulo_salida_disparo=90, frecuencia_de_disparo=5)
        self.aprender(pilas.habilidades.MoverseConElTeclado)
        self.y = -200
        self.aprender(pilas.habilidades.PuedeExplotar)
        hitbox = pilas.fisica.Rectangulo(0,250,30,50,dinamica=False)
        self.figura_de_colision = hitbox
        self.aprender("LimitadoABordesDePantalla")
    def actualizar(self):
        if pilas.control.izquierda:
            self.cuadro += 1
            self.espejado = True
            self.aprender(pilas.habilidades.Disparar, offset_origen_actor=(0,20), escala=0.5, municion='miMunicion', angulo_salida_disparo=90, frecuencia_de_disparo=5)
        if pilas.control.derecha:
            self.cuadro += 1
            self.espejado = False
            self.aprender(pilas.habilidades.Disparar, offset_origen_actor=(0,20), escala=0.5, municion='miMunicion', angulo_salida_disparo=90, frecuencia_de_disparo=5)
        if self.cuadro>7:
            self.cuadro = 0

        self.imagen.definir_cuadro(self.cuadro)
#Vinculando mi heroe
pilas.actores.vincular(Heroe)

class Cambio_de_Heroe(pilasengine.actores.Actor):
    def iniciar(self):
        self.imagen=pilas.imagenes.cargar("C:\omarpilas\imagenes\wnaves.png")
        self.aprender(pilas.habilidades.PuedeExplotarConHumo)
        self.escala = 0.05
        self.y = 250
        self.x = pilas.azar(-300,300)
        hitbox=pilas.fisica.Rectangulo(0,300,45,45,dinamica=False)
        self.figura_de_colision=hitbox
    def actualizar(self):
        self.y -=2
        if self.y <= -280:
            self.eliminar()
pilas.actores.vincular(Cambio_de_Heroe)
miGrupoCambio_de_Heroe = pilas.actores.Grupo()

def funcionCreandoCambio_de_Heroe():
    maloooh=pilas.actores.Cambio_de_Heroe()
    miGrupoCambio_de_Heroe.agregar(bart)
    
def colisionCambio_de_Heroe(nave, miGrupoCambio_de_Heroe):
    nave.imagen=pilas.imagenes.cargar("C:\omarpilas\imagenes\wnaves.png")

class Enemigo(pilasengine.actores.Actor):
    def iniciar(self):
        self.imagen = pilas.imagenes.cargar("C:\omarpilas\imagenes\wwwplayer.png")
        self.escala = 0.2
        self.y = 300
        self.x = pilas.azar(-320,320)
        hitbox = pilas.fisica.Rectangulo(0,250,30,40,dinamica=False)
        self.figura_de_colision = hitbox
        #self.velocidad = pilas.azar(0.1)
        self.aprender(pilas.habilidades.PuedeExplotarConHumo)
    def actualizar(self):
        self.y -= 14
        self.rotacion +=3
        if self.y < -280:
            self.eliminar()
pilas.actores.vincular(Enemigo)

class vidaaa(pilasengine.actores.Actor):
    def iniciar(self):
        self.imagen = pilas.imagenes.cargar("C:\omarpilas\imagenes\salvavidas.png")
        self.escala = 0.2
        self.y = 300
        self.x = pilas.azar(-320,320)
        hitbox = pilas.fisica.Rectangulo(0,250,30,40,dinamica=False)
        self.figura_de_colision = hitbox
        #self.velocidad = pilas.azar(0.1)
        self.aprender(pilas.habilidades.PuedeExplotarConHumo)
    def actualizar(self):
        self.y -= 14
        self.rotacion +=3
        if self.y < -280:
            self.eliminar()
pilas.actores.vincular(vidaaa)
      
vidi = pilas.actores.Grupo()


def funcionCreandoVidi():
    vyda = pilas.actores.vidaaa()
    vidi.agregar(vyda)
    


def cuanto_toca(jake, miGrupoRigby):
    jake = pilas.actores.Heroe()
    vidi.eliminar()   
pilas.colisiones.agregar(heroe, vidi, cuando_toca)
        


def colisionMeMuero(jake, miGrupoRigby):
    jake.vida -= 1
    miGrupoRigby.eliminar()
    if jake.vida == 0:
        pilas.escenas.EscenaPerdiste()

def colisionDisparo(miGrupoRigby, disparo):
    miGrupoRigby.eliminar()
    disparo.eliminar()

class nivel2(pilasengine.escenas.Escena):
    def iniciar(self):
        global cantidad_puntos
        global cantidad_vida
        cantidad_puntos=0
        cantidad_vida=3

        self.fondo = pilas.fondos.Fondo()
        self.fondo.imagen=pilas.imagenes.cargar("C:\omarpilas\imagenes\wlist_640px.png")
                
        jake = pilas.actores.Heroe()
        homero = pilas.actores.AntiHeroe()
        pilas.tareas.siempre(0.1, funcionCreandoEnemigos)
        
        #VIDA--------------------------
        self.puntos_de_vida = pilas.actores.Puntaje(x=200,y=200,color=pilas.colores.blanco)
        self.puntos_de_vida.definir(cantidad_vida)
        self.texto_vida = pilas.actores.Texto("Vida:", x=150,y=200)
        self.texto_vida.color = pilas.colores.blanco

        #Puntaje:------------------------------
        self.score = pilas.actores.Puntaje(x=-180,y=200,color=pilas.colores.blanco)
        self.score.definir(cantidad_puntos)
        #self.score.escala = 5
        self.texto_puntaje = pilas.actores.Texto("Puntitos:", x=-250, y=200)
        self.texto_puntaje.color = pilas.colores.blanco

        pilas.colisiones.agregar('Enemigo','miMunicion', self.sumar_puntos)
       
        pilas.colisiones.agregar(jake, miGrupoRigby, colisionMeMuero)
        
        pilas.colisiones.agregar('Heroe','Enemigo', self.restar_vidas)
        pilas.colisiones.agregar('Enemigo','miMunicion', self.sumar_puntos)
        pilas.colisiones.agregar('miMunicion','Antiheroe',self.matandohomero)
        pilas.colisiones.agregar('Enemigo','miMunicion',colision_eliminardisparo)
        
    def matandohomero(self):
        global cantidad_vidajefe
        cantidad_vidajefe -=50
        if cantidad_vidajefe <=0:
            pilas.escenas.EscenaGanaste()
    def restar_vidas(self):
        global cantidad_vida
        cantidad_vida -= 1
        self.puntos_de_vida.aumentar(-1)
        if cantidad_vida <=0:
            pilas.escenas.EscenaPerdiste();
            cantidad_vida = 3;

    def sumar_puntos(self):
        global cantidad_puntos
        self.score.aumentar(1)
        cantidad_puntos += 1          
                  
    def colisionMuerted(miMunicion, AntiHeroe):
        AntiHeroe.vida -=1
        if AntiHeroe.vida==8:
            AntiHeroe.eliminar()
        pilas.tareas.eliminar_todas()
        
def destruirAlDisparar_xD(AntiHeroe, miMunicion):
    miMunicion.eliminar()
    
def destruirAlDisparar_xD(gru, miMunicion):
    miMunicion.eliminar()

def colision_eliminardisparo(miGrupoRigby, disparo):
    miGrupoRigby.eliminar()
    disparo.eliminar()

pilas.escenas.vincular(nivel2)

class Enemigoo(pilasengine.actores.Actor):
    def iniciar(self):
        self.imagen = pilas.imagenes.cargar("C:\omarpilas\imagenes\Bart.png")
        self.escala =0.1
        self.y = 300
        self.x = pilas.azar(-300,300)
        hitbox = pilas.fisica.Rectangulo(0,250,30,40,dinamica=False)
        self.figura_de_colision = hitbox
        #self.velocidad = pilas.azar(0.1)
        self.aprender(pilas.habilidades.PuedeExplotarConHumo)
    def actualizar(self):
        self.y -= 7
        self.rotacion +=10
        if self.y < -280:
            self.eliminar()
pilas.actores.vincular(Enemigoo)

def colisionMeMueroo(jake, miGrupoRigbyy):
    jake.vida -= 1
    miGrupoRigbyy.eliminar()
    if jake.vida == 0:
        pilas.escenas.EscenaPerdiste()

#Grupo de enemigos :)
miGrupoRigbyy = pilas.actores.Grupo()

#Función para crear enemigos y agregarlos al grupo
def funcionCreandoEnemigoos():
    enemigoo = pilas.actores.Enemigoo()
    miGrupoRigbyy.agregar(enemigoo)

#Defino que la escena que contiene el menu es la primera escena:
pilas.escenas.EscenaMenu()
pilas.ejecutar()

[jordinur]

def cuanto_toca(jake, miGrupoRigby): 
    jake = pilas.actores.Heroe()
    vidi.eliminar() 
pilas.colisiones.agregar(heroe, vidi, cuando_toca)

Buenas, @lucas1!

Ufff tu código es MUY largo y complejo como para analizarlo a fondo.

A primera vista y sin testar parece que es en esa def en la que llamas a un tal “heroe” con minúscula.

Podrás probar a ponerlo en mayúscula?

o incluso mejor así:

def cuando_toca(jake, miGrupoRigby): 
    jake = pilas.actores.Heroe()
    vidi.eliminar() 
pilas.colisiones.agregar(jake, vidi, cuando_toca)

Aunque yo personalmente haría lo siguiente, ya que sinó lo que haces es crear un nuevo actor con 3 vidas:

def cuando_toca(jake, miGrupoRigby): 
    jake.vida += 1
    vidi.eliminar() 
pilas.colisiones.agregar(jake, vidi, cuando_toca)

Ten cuidado! La def es “cuanto_toca” pero tu estas llamando a “cuando_toca”

Tambien veo que en esa colisión llamas al heroe y a un grupo “vidi” (vidi en realidad es una lista o tupla), lo que hace imposible colisionar usando etiquetas.

No veo la necesidad de crear una lista o tupla en este caso. Vida debería ser una Class, con lo que podrías colisionarla con el Heroe usando etiquetas.

Veo que ya tienes una “class vidaaa” con lo cual la colision podría ser así:

def cuando_toca(heroe, vida_recibida): 
    heroe.vida +=1
    vida_recibida.eliminar()
 
pilas.colisiones.agregar('Heroe','vidaaa', cuando_toca)

Por cierto, es aconsejable que las class empiecen por Mayúscula para diferenciarlas de las def,
y tambien es aconsejable agrupar las class de escena y las class de actores bien diferenciadas entre sí, para mejor legibilidad del código.

Prueba eso y dinos si se solucionó ok?

Un saludo

PD: Te rechacé el segundo post por que me pareció que era el mismo duplicado. Si no es así haznoslo saber, ok?

[lucas1]

logre que colsionen pero no se como poder para que sume la vida me ayudas xfa

import pilasengine


pilas = pilasengine.iniciar()

#Variables GLOBALES
cantidad_puntos = 0
cantidad_vida = 3
cantidad_vidajefe = 200

#Funciones del menú:
def iniciar_juego():
    pilas.escenas.EscenaJuego() 
def salir_del_juego():
    pilas.terminar()
def instrucciones_del_juego():
    pilas.escenas.instrucciones()
    
def creditos_del_juego():
    pilas.escenas.creditos()

#Clase que corresponde a la PRIMERA ESCENA, que contiene un menú: 
class AntiHeroe(pilasengine.actores.Actor):
    def iniciar(self):
        self.imagen=pilas.imagenes.cargar("C:\omarpilas\imagenes\wh.png")
        self.escala_x=0.9
        self.escala_y=0.7
        #self.x=0
        self.y=300                  
        self.y=[100],3
        hitbox=pilas.fisica.Rectangulo(0,300,350,300,dinamica=False)
        self.figura_de_colision = hitbox
        
pilas.actores.vincular(AntiHeroe)


class creditos (pilasengine.escenas.Escena):
    def iniciar(self):
        self.f = pilas.fondos.Fondo()
        self.f.imagen = pilas.imagenes.cargar("C:\omarpilas\imagenes\creditos.jpg")
        self.f.escala=1.3
pilas.escenas.vincular(creditos)

class instrucciones (pilasengine.escenas.Escena):
    def iniciar(self):
        self.f = pilas.fondos.Fondo()
        self.f.imagen = pilas.imagenes.cargar("C:\omarpilas\imagenes\wespacio.png")
        self.f.escala=0.8
pilas.escenas.vincular(instrucciones)

class EscenaMenu(pilasengine.escenas.Escena):
    def iniciar(self):
        self.f = pilas.fondos.Fondo()
        self.f.escala_x =-200
        self.f.escala_y = 30
        self.f.escala= 0.8
        self.f.imagen = pilas.imagenes.cargar("C:\omarpilas\imagenes\wSpringfield.png")
        self.lista_de_opciones = pilas.actores.Menu([
            ("Jugar", iniciar_juego),
            ("Salir", salir_del_juego),
            ("instrucciones" , instrucciones_del_juego),
            ("creditos" , creditos_del_juego)
            
        ])
        texto_titulo = pilas.actores.Texto("the simpson")
        texto_titulo.x = [150,-150,0],0.5
        texto_titulo.y = 200
        texto_titulo.escala = [1.5,0.2,4],1

#Vinculo la escena
pilas.escenas.vincular(EscenaMenu)

class EscenaJuego(pilasengine.escenas.Escena):
    def iniciar(self):
        cantidad_puntos = 0;
        #pilas.forzar_habilitacion_de_audio()
        #fondo personalizado
        self.f = pilas.fondos.Fondo()
        self.f.imagen = pilas.imagenes.cargar("C:\omarpilas\imagenes\wwSpringfield.png")
        #tarea que crea enemigos siempre :v
        pilas.tareas.siempre(2, funcionCreandoEnemigos)
        pilas.tareas.siempre(2, funcionCreandoEnemigoos)
        
        jake = pilas.actores.Heroe()
        pilas.colisiones.agregar(jake,vidi, colisionVida)
        pilas.colisiones.agregar(jake, miGrupoRigbyy, colisionMeMueroo)
        pilas.tareas.siempre(0.8,funcionCreandoVidi)
        pilas.colisiones.agregar('Enemigo','miMunicion', colisionDisparo)
         
    
            
         #Puntaje:
        self.score = pilas.actores.Puntaje(x=-180,y=200,color=pilas.colores.blanco)
        self.score.definir(cantidad_puntos)
        #self.score.escala = 5
        self.texto_puntaje = pilas.actores.Texto("Puntitos:", x=-250, y=200)
        self.texto_puntaje.color = pilas.colores.blanco
        pilas.colisiones.agregar('Enemigo','miMunicion', self.sumar_puntos)
        
        #VIDA:
        self.puntos_de_vida = pilas.actores.Puntaje(x=200,y=200,color=pilas.colores.blanco)
        self.puntos_de_vida.definir(cantidad_vida)
        self.texto_vida = pilas.actores.Texto("Vida:", x=150,y=200)
        self.texto_vida.color = pilas.colores.blanco
        pilas.colisiones.agregar(jake, miGrupoRigby, self.restar_vidas)

    def restar_vidas(self):
        global cantidad_vida
        cantidad_vida -= 1
        self.puntos_de_vida.aumentar(-1)
        if cantidad_vida <=0:
            pilas.escenas.EscenaPerdiste();
            cantidad_vida = 3;
    
    def sumar_puntos(self):
        global cantidad_puntos
        self.score.aumentar(1)
        cantidad_puntos += 1
        if (cantidad_puntos >=1):
            pilas.escenas.nivel2 ();
            cantidad_puntos = 0;

#VINCULAR LA ESCENA DE JUEGO:
pilas.escenas.vincular(EscenaJuego)

class EscenaPerdiste(pilasengine.escenas.Escena):
    def iniciar(self):
        self.f = pilas.fondos.Fondo()
        self.f.y = 30
        self.f.escala= 1.2
        self.f.imagen = pilas.imagenes.cargar("C:\omarpilas\imagenes\homerooo.jpg")
        self.f.escala_x=2
        self.f.escala_y=1.5
        self.textito = pilas.actores.Texto("perdiste")
        self.textito.x=0
        self.textito.y=100
        btn_volver = pilas.interfaz.Boton("VOLVER")
        btn_volver.conectar(funcionVolverMenu)
pilas.escenas.vincular(EscenaPerdiste)

def funcionVolverMenu():
    pilas.escenas.EscenaMenu()
 

class EscenaGanaste(pilasengine.escenas.Escena):
    def iniciar(self):
        self.f = pilas.fondos.Fondo()
        self.f.y = 30
        self.f.escala= 1.2
        self.f.imagen = pilas.imagenes.cargar("C:\omarpilas\imagenes\whomero.png")
        self.f.escala_x=1
        self.f.escala_y=0.6
        btn_volver = pilas.interfaz.Boton("VOLVER")
        btn_volver.conectar(funcionVolverMenu)
        texto_titulo = pilas.actores.Texto("Ganaste")
        texto_titulo.y = 200

#Vinculo la escena
pilas.escenas.vincular(EscenaGanaste)

#Grupo de enemigos :)
miGrupoRigby = pilas.actores.Grupo()
#Función para crear enemigos y agregarlos al grupo
def funcionCreandoEnemigos():
    enemigo = pilas.actores.Enemigo()
    miGrupoRigby.agregar(enemigo)

class miMunicion(pilasengine.actores.Actor):
    def iniciar(self):
        self.imagen = pilas.imagenes.cargar_grilla("C:\omarpilas\imagenes\wfuego.png",4)
        self.cuadro = 0
pilas.actores.vincular(miMunicion)

#Creando nuestra clase heroe
class Heroe(pilasengine.actores.Actor):
    def iniciar(self):
        self.imagen = pilas.imagenes.cargar("C:\omarpilas\imagenes\www.png");
        self.escala=0.1
        self.vida = 3
        self.cuadro=0
        self.aprender(pilas.habilidades.SeMantieneEnPantalla)
        self.aprender(pilas.habilidades.Disparar, offset_origen_actor=(0,20), escala=0.5, municion='miMunicion', angulo_salida_disparo=90, frecuencia_de_disparo=5)
        self.aprender(pilas.habilidades.MoverseConElTeclado)
        self.y = -200
        self.aprender(pilas.habilidades.PuedeExplotar)
        hitbox = pilas.fisica.Rectangulo(0,250,30,50,dinamica=False)
        self.figura_de_colision = hitbox
        self.aprender("LimitadoABordesDePantalla")
    def actualizar(self):
        if pilas.control.izquierda:
            self.cuadro += 1
            self.espejado = True
            self.aprender(pilas.habilidades.Disparar, offset_origen_actor=(0,20), escala=0.5, municion='miMunicion', angulo_salida_disparo=90, frecuencia_de_disparo=5)
        if pilas.control.derecha:
            self.cuadro += 1
            self.espejado = False
            self.aprender(pilas.habilidades.Disparar, offset_origen_actor=(0,20), escala=0.5, municion='miMunicion', angulo_salida_disparo=90, frecuencia_de_disparo=5)
        if self.cuadro>7:
            self.cuadro = 0

        self.imagen.definir_cuadro(self.cuadro)
#Vinculando mi heroe
pilas.actores.vincular(Heroe)

class Cambio_de_Heroe(pilasengine.actores.Actor):
    def iniciar(self):
        self.imagen=pilas.imagenes.cargar("C:\omarpilas\imagenes\wnaves.png")
        self.aprender(pilas.habilidades.PuedeExplotarConHumo)
        self.escala = 0.05
        self.y = 250
        self.x = pilas.azar(-300,300)
        hitbox=pilas.fisica.Rectangulo(0,300,45,45,dinamica=False)
        self.figura_de_colision=hitbox
    def actualizar(self):
        self.y -=2
        if self.y <= -280:
            self.eliminar()
pilas.actores.vincular(Cambio_de_Heroe)
miGrupoCambio_de_Heroe = pilas.actores.Grupo()

def funcionCreandoCambio_de_Heroe():
    maloooh=pilas.actores.Cambio_de_Heroe()
    miGrupoCambio_de_Heroe.agregar(bart)
    
def colisionCambio_de_Heroe(nave, miGrupoCambio_de_Heroe):
    nave.imagen=pilas.imagenes.cargar("C:\omarpilas\imagenes\wnaves.png")

class Enemigo(pilasengine.actores.Actor):
    def iniciar(self):
        self.imagen = pilas.imagenes.cargar("C:\omarpilas\imagenes\wwwplayer.png")
        self.escala = 0.2
        self.y = 300
        self.x = pilas.azar(-320,320)
        hitbox = pilas.fisica.Rectangulo(0,250,30,40,dinamica=False)
        self.figura_de_colision = hitbox
        #self.velocidad = pilas.azar(0.1)
        self.aprender(pilas.habilidades.PuedeExplotarConHumo)
    def actualizar(self):
        self.y -= 14
        self.rotacion +=3
        if self.y < -280:
            self.eliminar()
pilas.actores.vincular(Enemigo)

class Vidaaa(pilasengine.actores.Actor):
    def iniciar(self):
        self.imagen = pilas.imagenes.cargar("C:\omarpilas\imagenes\salvavidas.png")
        self.escala = 0.2
        self.y = 300
        self.x = pilas.azar(-320,320)
        hitbox = pilas.fisica.Rectangulo(0,250,30,40,dinamica=False)
        self.figura_de_colision = hitbox
        #self.velocidad = pilas.azar(0.1)
        self.aprender(pilas.habilidades.PuedeExplotarConHumo)
    def actualizar(self):
        self.y -= 14
        self.rotacion +=3
        if self.y < -280:
            self.eliminar()
pilas.actores.vincular(vidaaa)
      
vidi = pilas.actores.Grupo()


def funcionCreandoVidi():
    vyda = pilas.actores.vidaaa()
    vidi.agregar(vyda)
    


    def sumar_vidas(jake,vidi):
        global cantidad_vidaa
        cantida_vidaa += 1
        self.puntos_de_vida.aumentar(+1)
        if cantidad_vida <=9:
            cantidad_vida = 9;
        

        


def colisionMeMuero(jake, miGrupoRigby):
    jake.vida -= 1
    miGrupoRigby.eliminar()
    if jake.vida == 0:
        pilas.escenas.EscenaPerdiste()

def colisionDisparo(miGrupoRigby, disparo):
    miGrupoRigby.eliminar()
    disparo.eliminar()

class nivel2(pilasengine.escenas.Escena):
    def iniciar(self):
        global cantidad_puntos
        global cantidad_vida
        cantidad_puntos=0
        cantidad_vida=3

        self.fondo = pilas.fondos.Fondo()
        self.fondo.imagen=pilas.imagenes.cargar("C:\omarpilas\imagenes\wlist_640px.png")
                
        jake = pilas.actores.Heroe()
        homero = pilas.actores.AntiHeroe()
        pilas.tareas.siempre(0.1, funcionCreandoEnemigos)
        
        #VIDA--------------------------
        self.puntos_de_vida = pilas.actores.Puntaje(x=200,y=200,color=pilas.colores.blanco)
        self.puntos_de_vida.definir(cantidad_vida)
        self.texto_vida = pilas.actores.Texto("Vida:", x=150,y=200)
        self.texto_vida.color = pilas.colores.blanco

        #Puntaje:------------------------------
        self.score = pilas.actores.Puntaje(x=-180,y=200,color=pilas.colores.blanco)
        self.score.definir(cantidad_puntos)
        #self.score.escala = 5
        self.texto_puntaje = pilas.actores.Texto("Puntitos:", x=-250, y=200)
        self.texto_puntaje.color = pilas.colores.blanco

        pilas.colisiones.agregar('Enemigo','miMunicion', self.sumar_puntos)
       
        pilas.colisiones.agregar(jake, miGrupoRigby, colisionMeMuero)
        
        pilas.colisiones.agregar('Heroe','Enemigo', self.restar_vidas)
        pilas.colisiones.agregar('Enemigo','miMunicion', self.sumar_puntos)
        pilas.colisiones.agregar('miMunicion','Antiheroe',self.matandohomero)
        pilas.colisiones.agregar('Enemigo','miMunicion',colision_eliminardisparo)
        
    def matandohomero(self):
        global cantidad_vidajefe
        cantidad_vidajefe -=50
        if cantidad_vidajefe <=0:
            pilas.escenas.EscenaGanaste()
    
    def restar_vidas(self):
        global cantidad_vida
        cantidad_vida -= 1
        self.puntos_de_vida.aumentar(-1)
        if cantidad_vida <=0:
            pilas.escenas.EscenaPerdiste();
            cantidad_vida = 3;

    def sumar_puntos(self):
        global cantidad_puntos
        self.score.aumentar(1)
        cantidad_puntos += 1          
                  
    def colisionMuerted(miMunicion, AntiHeroe):
        AntiHeroe.vida -=1
        if AntiHeroe.vida==8:
            AntiHeroe.eliminar()
        pilas.tareas.eliminar_todas()
        
def destruirAlDisparar_xD(AntiHeroe, miMunicion):
    miMunicion.eliminar()
    
def destruirAlDisparar_xD(gru, miMunicion):
    miMunicion.eliminar()

def colision_eliminardisparo(miGrupoRigby, disparo):
    miGrupoRigby.eliminar()
    disparo.eliminar()

pilas.escenas.vincular(nivel2)

class Enemigoo(pilasengine.actores.Actor):
    def iniciar(self):
        self.imagen = pilas.imagenes.cargar("C:\omarpilas\imagenes\Bart.png")
        self.escala =0.1
        self.y = 300
        self.x = pilas.azar(-300,300)
        hitbox = pilas.fisica.Rectangulo(0,250,30,40,dinamica=False)
        self.figura_de_colision = hitbox
        #self.velocidad = pilas.azar(0.1)
        self.aprender(pilas.habilidades.PuedeExplotarConHumo)
    def actualizar(self):
        self.y -= 7
        self.rotacion +=10
        if self.y < -280:
            self.eliminar()
pilas.actores.vincular(Enemigoo)

def colisionMeMueroo(jake, miGrupoRigbyy):
    jake.vida -= 1
    miGrupoRigbyy.eliminar()
    if jake.vida == 0:
        pilas.escenas.EscenaPerdiste()

#Grupo de enemigos :)
miGrupoRigbyy = pilas.actores.Grupo()

#Función para crear enemigos y agregarlos al grupo
def funcionCreandoEnemigoos():
    enemigoo = pilas.actores.Enemigoo()
    miGrupoRigbyy.agregar(enemigoo)

#Defino que la escena que contiene el menu es la primera escena:
pilas.escenas.EscenaMenu()
pilas.ejecutar()

[jordinur]

Buenas, @lucas1

Quizás si me dices qué colisión no te funciona podría ver qué falla, pero como ya te dije anteriormente tu código es muy extenso y enmarañado como para hacer un analisis en profundidad.

Lo que aún no entiendo es el porqué creas grupos y añades ahí a tus actores… no es necesario crear grupos para crear colisiones, y tampoco veo que una vez eliminados los borres del grupo… entonces para que los pones en grupos???

Por favor, dime qué colisión es la que te falla e intentaré ayudarte un poco más, ok?

Voy a intentar ejecutar tu juego en mi pc (aunque va a ser un trabajo ya que no tengo tus archivos
de imágenes) a ver si viendo la mecánica del juego puedo entender mejor tu duda.

Un saludo

[jordinur]

A ver si este ejemplo te sirve para guiarte… Lo hice hace tiempo y lo he adaptado para que se parezca a tu idea original

Fíjate que yo intento simplificar al máximo el código, y que integro en cada class sus atributos propios para no tener que estar haciendo defs innecesarias. No tengo ninguna def fuera de ninguna class, y tampoco preciso de ninguna variable global.

Por eso creo que es MUY importante un planteamiento previo, planificar bien qué vas a necesitar y cual es la manera más sencilla de conseguirlo

Espero que mi ejemplo te sirva como guía!

Fíjate que las colisiones están todas dentro de la def iniciar de la escena, que es el mejor lugar para declararlas

EDITO PARA RECTIFICAR CÓDIGO: Por error te puse la versión inicial en la que no sumaba vidas . Ahora ya está completo

import pilasengine
pilas = pilasengine.iniciar()


class MiMunicion(pilasengine.actores.Actor):
	def iniciar(self):
		self.imagen = 'disparo.png'
		self.aprender('eliminarseSiSaleDePantalla')
		
pilas.actores.vincular(MiMunicion)


class Vida_extra(pilasengine.actores.Actor):
	def iniciar(self):
		self.imagen = 'estrella.png'
		self.escala = .6
		
		self.x = pilas.azar(-200,200)
		self.y = 400
		
		self.aprender('puedeExplotarConHumo')
		
	def actualizar(self):
		self.y -= 1
		if self.y <= -200:
			self.eliminar()

pilas.actores.vincular(Vida_extra)

class Heroe(pilasengine.actores.Actor):
	
	def iniciar(self):
		self.vidas = 3
		self.imagen = 'nave_roja/nave.png'
		self.escala = .6
		
		self.aprender('seMantieneEnPantalla')
		self.aprender('moverseConElTeclado')
		self.aprender('disparar', municion='MiMunicion', angulo_salida_disparo = 90)
	
pilas.actores.vincular(Heroe)


class Enemigo(pilasengine.actores.Actor):
	
	def iniciar(self, tipo):
		
		self.tipo =  tipo
		
		self.aprender('puedeExplotarConHumo')
		
		if self.tipo == 'normal':
			
			self.x = pilas.azar(-200,200)
			self.y = 400
			
			self.vida = 1
			self.imagen = 'aceituna.png'
			
			
		elif self.tipo == 'Boss':
			self.x = 0
			self.y = 200
			
			#### Solo como dato informativo ###
			self.vidas_iniciales = 10
			###-----------------------------###
			
			self.vida = 10 # Estas son las vidas reales del Boss
			
			self.imagen = 'mono.png'
			self.escala = .7
			
			self.y = (200,50), 3
			
			def BossHabla():
				self.decir('SOY UN BOSS Y TENGO '+str(self.vidas_iniciales)+' VIDAS')
			
			pilas.tareas.agregar(3, BossHabla)
			
			
		else:
			pilas.avisar('Enemigo mal declarado')
			
			
	def actualizar(self):
		
		if self.vida <= 0:
			self.eliminar()
			
		if self.tipo == 'normal':
			self.y -= 1
			
			if self.y <= -230 and self.tipo == 'normal':
				self.eliminar()
			
pilas.actores.vincular(Enemigo)


class EscenaJuego(pilasengine.escenas.Escena):
	
	def iniciar(self):
		self.fondo = pilas.fondos.Galaxia()
		
		self.heroe = pilas.actores.Heroe()
		
		self.puntos = pilas.actores.Puntaje()
		self.puntos.valorInicial = 0
		self.puntos.x = -280
		self.puntos.y = 180
		self.puntos.color = pilas.colores.blanco
		
		self.contador_enemigos = 0
		
		### TAREAS ###
		self.tarea_crear_enemigos = pilas.tareas.siempre(1, self.crear_enemigos_normales)
		
		self.tarea_crear_vidas = pilas.tareas.siempre(5, self.crear_vidas)
		
		
		###COLISIONES
		pilas.colisiones.agregar('MiMunicion', 'Enemigo', self.restar_vida_enemigo)
		
		pilas.colisiones.agregar('Heroe', 'Enemigo', self.restar_vida_heroe)
		
		pilas.colisiones.agregar('Heroe','Vida_extra', self.vida_extra)
		
		
	def crear_enemigos_normales(self):
		self.enemigo = pilas.actores.Enemigo(tipo='normal')
		
		self.contador_enemigos +=1
		
		if self.contador_enemigos >= 20:
			self.tarea_crear_enemigos.eliminar()
			self.crear_Boss()
	
	def crear_Boss(self):
		self.enemigo = pilas.actores.Enemigo(tipo ='Boss')
		
		
	def crear_vidas(self):
		estrella = pilas.actores.Vida_extra()
		
		
	def vida_extra(self, minave, estrella):
		estrella.eliminar()
		if minave.vidas <3:
			minave.vidas += 1
			pilas.avisar('Vidas restantes: ' + str(minave.vidas))
		else:
			pilas.avisar(u'Las vidas ya están al máximo')
	
	
	def restar_vida_enemigo(self, bala, objetivo):
		# pilas.avisar('Colision')
		if objetivo.tipo == 'Boss' and objetivo.vida == 1:
			pilas.tareas.agregar(3, self.ir_a_escena_ganar)
		
		bala.eliminar()
		objetivo.vida -= 1
		self.puntos.aumentar()
		
	
	def restar_vida_heroe(self, minave, villano):
		minave.vidas -= 1
		pilas.avisar('Vidas restantes: ' + str(minave.vidas))
		
		if minave.vidas <=0:
			minave.eliminar()
			pilas.tareas.agregar(3, self.ir_a_escena_perder)
		
		if villano.tipo == 'normal':
			villano.eliminar()
		elif villano.tipo == 'Boss':
			villano.decir('JA JA JA')
			
	def ir_a_escena_perder(self):
		pilas.escenas.EscenaPerder()
		
		
	def ir_a_escena_ganar(self):
		pilas.escenas.EscenaGanar()
		
		
class EscenaPerder(pilasengine.escenas.Escena):
	def iniciar(self):
		self.fondo = pilas.fondos.Tarde()
		pilas.avisar('PERDISTE!!!')
		
		
class EscenaGanar(pilasengine.escenas.Escena):
	def iniciar(self):
		self.fondo = pilas.fondos.Selva()
		pilas.avisar('GANASTE!!!')
		


pilas.escenas.vincular(EscenaJuego)
pilas.escenas.vincular(EscenaPerder)
pilas.escenas.vincular(EscenaGanar)

pilas.escenas.EscenaJuego()

pilas.ejecutar()