Como hacer que lluevan palabras

Buenos días, alguien me podría ayudar a que caigan palabras y poder subir mi puntaje cuando ingrese bien la palabra por enterfaz ingreso_de_texto ??
Soy estudiante y vi poco de Python, Ahora me piden un juego con la siguiente consigna:
tenga Menú(Inicio del Juego, Score con nombre de usuario, Salir del Juego)
Inicio del Juego(Puntaje, Vidas, palabra incorrecta, veces q borro, palabras q salieron de pantalla)
Score (nombre del jugadores, sus puntajes, palabra incorrecta, veces que borro, palabras q salieron de pantalla).
Este es mi drama, SOLO PIDO SABER COMO HACER Q LLUEVAN PALABRAS Y DEFINIRLAS COMO ENEMIGO PARA QUE DESAPAREZCAN UNA VEZ INGRESADO LA PALABRA CORRECTA POR TECLADO.
Les paso lo que tengo hasta ahora.
PD: La tenia casi promocionada la materia pero el profe nos puso regular a todos y si presentabamos el juego para el 11/12 la aprobaba.

# -*- encoding: utf-8 -*-
import pilasengine
import os
import random

pilas = pilasengine.iniciar()

#cancion_de_fondo = pilas.musica.cargar('Combo_Breaker_Japan.mp3')
#cancion_de_fondo.reproducir()

### Algunas funciones para el juego ###
###def lista_palabras()
    


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

#"""class IngresoTexto(pilasengine.interfaz.ingreso_de_texto):"""

def iniciar_juego():
    pilas.escenas.EscenaJuego()


def records():
    pilas.escenas.EscenaRecords()

def salir_del_juego():
    pilas.terminar()
    cancion_de_fondo.detener()
	

class TextoEnemigo(pilasengine.actores.Texto):

    def __init__(self, *k, **kw):
        pilasengine.actores.Texto.__init__(self, *k, **kw)
        self.post_iniciar()
    
    def post_iniciar(self):

        self.x = pilas.azar(-200, 200)
        self.y = 290
        self.velocidad = pilas.azar(10, 11) / 5.0

    def actualizar(self):
        self.y -= self.velocidad

        # Elimina el objeto cuando sale de la pantalla.
        if self.y < -300:
            self.eliminar()


	

	
class EscenaMenu(pilasengine.escenas.Escena):

    def iniciar(self):
        MenuPrincipal = pilas.fondos.Tarde()
        mennu = pilas.actores.Menu([('Iniciar juego', iniciar_juego),
		                            ('Records', records),
									('Salir', salir_del_juego)])
        mennu.color = "amarillo"
        mennu.escala =1.3
		

        self._crear_el_titulo_del_juego()


    def _crear_el_titulo_del_juego(self):
        titulo = self.pilas.actores.Texto("MATA PALABRAS", magnitud=30, y=50)
        titulo.y = 300
        titulo.rotacion = 30
        titulo.y = [100], 1
        titulo.rotacion = [0], 1.2


        
listas = ["BAUTISTA","SILLA","MURCIELAGO","MESA",
          "PROGRAMA","FACTURA","ARQUITECTURA","CARA"]


        

class EscenaJuego(pilasengine.escenas.Escena):

    def iniciar(self):
        self.pilas.fondos.Galaxia(dy=-5)
        #fondo = pilas.fondos.Galaxia(dy=-5)
        self.pilas.tareas.siempre(3, self._crear_un_actor_texto)
        #self.pilas.eventos.click_de_mouse.conectar(self._cuando_hace_click)
        self.puntaje = pilas.actores.Puntaje(290, 200, color="blanco")


		
    def _crear_un_actor_texto(self):
        #actor = TextoEnemigo(pilas, texto="BAUTISTA")
        #enemigos.agregar(actor)
		
        self.pilas.actores.TextoEnemigo(listas[2])


		
		
class TextoEnemigo(pilasengine.actores.Texto):

    def __init__(self, *k, **kw):
        pilasengine.actores.Texto.__init__(self, *k, **kw)
        self.post_iniciar()
    
    def post_iniciar(self):

        self.x = pilas.azar(-200, 200)
        self.y = 290
        self.velocidad = pilas.azar(10, 11) / 5.0

    def actualizar(self):
        self.y -= self.velocidad

        # Elimina el objeto cuando sale de la pantalla.
        if self.y < -300:
            self.eliminar()



                
class EscenaRecords(pilasengine.escenas.Escena):

    def iniciar(self):
        fondoh = pilas.fondos.Noche()
        #fondoh.imagen = pilas.imagenes.cargar("EscenaRecords.png")
        menuu = pilas.actores.Menu([('Volver al menu', volveralmenu)])
        menuu.y = -200        


## Vinculamos todas las escenas.
pilas.escenas.vincular(EscenaMenu)
pilas.escenas.vincular(EscenaJuego)
pilas.escenas.vincular(EscenaRecords)


## Vinculamos los actores Personalizados
#pilas.actores.vincular(BotonVolver)
pilas.actores.vincular(TextoEnemigo)
#pilas.actores.vincular(ActorEliminado)
#pilas.actores.vincular(IngresoTexto)


# Se inicia la escena principal.
pilas.escenas.EscenaMenu()

pilas.ejecutar()

Buenas, @javibautista !

A ver si este ejemplo te sirve para guiarte:

fíjate que más que usar class he preferido usar las tareas propias de pilas.

Un saludo :wink:

import pilasengine
import random

pilas = pilasengine.iniciar()

palabras_posibles = ["cero","uno","dos","tres","cuatro","cinco","seis","siete","ocho","nueve"]
indice_palabras = 1
creadas = []

def crear_palabra():
	global palabras_posibles, creadas, indice_palabras
	
	if indice_palabras < 20:#ponemos un límite al tiempo de juego
		palabra = random.choice(palabras_posibles)
		
		pala = pilas.actores.Texto(palabra, x=pilas.azar(-260,260), y=230)
		pala.y=[-280],5
		#pala.rotacion=[0,360],2
			
		creadas.append(pala.texto)
		
		indice_palabras += 1
		
		def borrar():
			if pala.y < -250:
				creadas.remove(pala.texto)
				pala.eliminar()
				tarea_borrar.terminar()
			else:
				pass
		
		tarea_borrar = pilas.tareas.siempre(1, borrar)
		
	else:
		tarea_crear.terminar()
		#tarea_contar_eliminables.terminar()#activar para control
		pilas.avisar('Fin del Nivel  1')
	
def contar_eliminables():
	'''Esta def es a efectos de control,
	no es necesaria para el juego '''
	global creadas, indice_palabras
	
	indice = str(indice_palabras)
	cuantas = str(len(creadas))
	eliminables = list(creadas)
	
	print('Palabras creadas: ' + indice)
	print("Palabras eliminables: " + cuantas)
	print(eliminables)


#tarea_contar_eliminables = pilas.tareas.siempre(0.5, contar_eliminables)#activar para control	

tarea_crear = pilas.tareas.siempre(2, crear_palabra)

pilas.ejecutar()  
1 me gusta

Hola @javibautista!,

Sumado a lo que dice @jordinur, agregué un campo de texto a tu código y una tarea para eliminar cualquier actor que contenga el texto ingresado.

¿Algo así era lo que buscabas del juego?

# -*- encoding: utf-8 -*-
import pilasengine
import os
import random

pilas = pilasengine.iniciar()

#cancion_de_fondo = pilas.musica.cargar('Combo_Breaker_Japan.mp3')
#cancion_de_fondo.reproducir()

### Algunas funciones para el juego ###
###def lista_palabras()
    


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

#"""class IngresoTexto(pilasengine.interfaz.ingreso_de_texto):"""

def iniciar_juego():
    pilas.escenas.EscenaJuego()


def records():
    pilas.escenas.EscenaRecords()

def salir_del_juego():
    pilas.terminar()
    cancion_de_fondo.detener()
	

class TextoEnemigo(pilasengine.actores.Texto):

    def __init__(self, *k, **kw):
        pilasengine.actores.Texto.__init__(self, *k, **kw)
        self.post_iniciar()
    
    def post_iniciar(self):

        self.x = pilas.azar(-200, 200)
        self.y = 290
        self.velocidad = pilas.azar(10, 11) / 5.0

    def actualizar(self):
        self.y -= self.velocidad

        # Elimina el objeto cuando sale de la pantalla.
        if self.y < -300:
            self.eliminar()


	

	
class EscenaMenu(pilasengine.escenas.Escena):

    def iniciar(self):
        MenuPrincipal = pilas.fondos.Tarde()
        mennu = pilas.actores.Menu([('Iniciar juego', iniciar_juego),
		                            ('Records', records),
									('Salir', salir_del_juego)])
        mennu.color = "amarillo"
        mennu.escala =1.3
		

        self._crear_el_titulo_del_juego()


    def _crear_el_titulo_del_juego(self):
        titulo = self.pilas.actores.Texto("MATA PALABRAS", magnitud=30, y=50)
        titulo.y = 300
        titulo.rotacion = 30
        titulo.y = [100], 1
        titulo.rotacion = [0], 1.2


        
listas = ["BAUTISTA","SILLA","MURCIELAGO","MESA",
          "PROGRAMA","FACTURA","ARQUITECTURA","CARA"]


        

class EscenaJuego(pilasengine.escenas.Escena):

    def iniciar(self):
        self.pilas.fondos.Galaxia(dy=-5)
        #fondo = pilas.fondos.Galaxia(dy=-5)
        self.pilas.tareas.siempre(3, self._crear_un_actor_texto)
        #self.pilas.eventos.click_de_mouse.conectar(self._cuando_hace_click)
        self.puntaje = pilas.actores.Puntaje(290, 200, color="blanco")
        self.crear_ingreso_de_texto()
        
        self.textos_en_pantalla = []

		
    def _crear_un_actor_texto(self):
        #actor = TextoEnemigo(pilas, texto="BAUTISTA")
        #enemigos.agregar(actor)
        hasta = len(listas)
        texto = listas[pilas.azar(0, hasta-1)]
        actor = self.pilas.actores.TextoEnemigo(texto)
        self.textos_en_pantalla.append(actor)

    def crear_ingreso_de_texto(self):
        self.ingreso = self.pilas.interfaz.IngresoDeTexto("", y=-200)

        self.tareas.siempre(0.2, self._revisar_textos_a_eliminar)
        
    def _revisar_textos_a_eliminar(self):
        for actor in self.textos_en_pantalla:
            if actor.esta_eliminado():
                continue
            #print([actor.texto], "-", [self.ingreso.texto])
            if self.ingreso.texto and str(actor.texto).lower() in str(self.ingreso.texto).lower():
                self.ingreso.texto = ""
                self.textos_en_pantalla.remove(actor)
                #self.pilas.actores.Explosion(actor.x, actor.y)
                actor.eliminar()
                print("Eliminando actor:", actor.texto)
        



class TextoEnemigo(pilasengine.actores.Texto):

    def __init__(self, *k, **kw):
        pilasengine.actores.Texto.__init__(self, *k, **kw)
        self.post_iniciar()
    
    def post_iniciar(self):

        self.x = pilas.azar(-200, 200)
        self.y = 290
        self.velocidad = pilas.azar(10, 11) / 5.0

    def actualizar(self):
        self.y -= self.velocidad

        # Elimina el objeto cuando sale de la pantalla.
        if self.y < -250:
            self.eliminar()



                
class EscenaRecords(pilasengine.escenas.Escena):

    def iniciar(self):
        fondoh = pilas.fondos.Noche()
        #fondoh.imagen = pilas.imagenes.cargar("EscenaRecords.png")
        menuu = pilas.actores.Menu([('Volver al menu', volveralmenu)])
        menuu.y = -200        


## Vinculamos todas las escenas.
pilas.escenas.vincular(EscenaMenu)
pilas.escenas.vincular(EscenaJuego)
pilas.escenas.vincular(EscenaRecords)


## Vinculamos los actores Personalizados
#pilas.actores.vincular(BotonVolver)
pilas.actores.vincular(TextoEnemigo)
#pilas.actores.vincular(ActorEliminado)
#pilas.actores.vincular(IngresoTexto)


# Se inicia la escena principal.
#pilas.escenas.EscenaMenu()
pilas.escenas.EscenaJuego()


pilas.ejecutar()

Probalo y contanos si era así.

¡Abrazo!

1 me gusta

Buenas!

Un placer,como siempre que Hugo nos ofrece sus conocimientos :smile:

Sin querer corregir, sí que me gustaría aportar un pequeño granito:

entrada = pilas.interfaz.IngresoDeTexto(texto="",ancho=200,x=0,y=-220)
entrada.tiene_el_foco=True

Al incluir tiene_el_foco=True nos aseguramos de que al iniciar el juego no tengamos que clicar en la entrada de texto para activarla (por defecto está desactivada)

De esta manera, tan pronto se carga el juego se puede empezar a teclear. :

(Es que la idea del juego me gustó y me hice uno propio para mi disfrute :joy: , aunque sin escenas ni class).

Un saludo :wink:

1 me gusta

Hola @jordinur
si me sirve muchisimo, para entender y ponerlo en class.
Gracias por darme una mano, ahora afinare detalles que me quedan.
Muchas gracias

Hola @hugoruscitti Mil gracias por darme una mano. Es exactamente lo que buscaba,
ahora me toca afinar detalles como las vidas,errores, correctas, records y demás. En caso de que vuelva a trabarme en algún punto los volveré a molestar. :sweat_smile:

Uds. son geniales, desde que estoy en esto he conocido personas, compañeros dispuestos a ayudar.

Gracias!!!

Gracias, lo agregue y probé, quedo genial. Me faltaría correr vidas e incorrectos en palabras,(ejemplos que vi en imágenes). Pero de contar veces q se borró aún no, logro resolverlo les pediré un empujoncito mas :scream:

PD: Si quieres compartir tu juego no me molesta he…:joy: :joy: :joy: :innocent:

Gracias!!!

Una última pregunta. habrá ejemplos de que me cuente por teclado las veces que borro letras cuando ingreso la palabra?
Tengo ejemplos de imagenes de palabras para incorrectas y descuento de vidas para incorrectas.Pero nada de veces que uno borra y tenga contador de ello.

Otra vez ¡Muchisimas gracias! por la mano que me dieron, es la última materia a aprobar y con este trabajo casi esta en la bolsa :smiley: :wink:

Buenas, @javibautista !

Hace tiempo yo mismo le consulté a Hugo como ligar eventos a diferentes teclas. Él me hizo un pequeño código para identificar los códigos de las teclas:

def al_pulsar_tecla(tecla):
    print(tecla)

pilas.eventos.pulsa_tecla.conectar(al_pulsar_tecla) 

Gracias a este pequeño programa si lo ejecutas en pilas te dirá el código de cualquier tecla que pulses. En este caso la tecla “retroceso” es el código 16777219

entonces, para saber cuantas veces se le da a la recla retroceso:

import pilasengine

pilas = pilasengine.iniciar()

contador_retrocesos = 0

puntaje_retrocesos = pilas.actores.Puntaje()
puntaje_retrocesos.valor_inicial = 0
puntaje_retrocesos.x=0
puntaje_retrocesos.y=100

def al_pulsar_retroceso(tecla):
	
	global contador_retrocesos
	
	if tecla.codigo == 16777219:
		contador_retrocesos +=1
		puntaje_retrocesos.aumentar(1)
		print(str(contador_retrocesos))

pilas.eventos.pulsa_tecla.conectar(al_pulsar_retroceso)

pilas.ejecutar()

Un saludo :wink:

1 me gusta

Al subirlo aquí me acabo de dar cuenta de que todas las referencias a la lista “creadas” son del todo innecesarias, ya que en ningún momento llamo a comparar las palabras con las de esa lista, y el método de “matar” está incluido en la misma creación de las palabras… :joy: :joy: :joy:
Mira que soy despistado… :sweat_smile:

import pilasengine
import random

pilas = pilasengine.iniciar()

fondo = pilas.fondos.Galaxia()

entrada = pilas.interfaz.IngresoDeTexto(texto="",ancho=200,x=0,y=-220)
entrada.tiene_el_foco=True

puntos = pilas.actores.Puntaje(x=280,y=220,color=pilas.colores.amarillo)
puntos.valor_inicial = "0"


palabras_posibles_1 = ["cero","uno","dos","tres","cuatro","cinco","seis","siete","ocho","nueve"]
palabras_posibles_2 = ["ornitorrinco","esternomascloideo","deshaucio","peripatetico","antropomorfico","heterogeneo","hexadecimal","supercalifragilisticoespialidoso","supuestamente","tergivesado","pluscuamperfecto"]

nivel = 1 # poner 1 o 2 según se desee ;)
indice_palabras = 1
creadas = []

def crear_palabra():
	global palabras_posibles_1, palabras_posibles_2, creadas, indice_palabras, entrada

	if indice_palabras < 20:#ponemos un límite al tiempo de juego
		if nivel == 1:	
			palabra = random.choice(palabras_posibles_1)
			pala = pilas.actores.Texto(palabra, x=pilas.azar(-260,260), y=230)
			pala.y=[-260],7
		
		elif nivel == 2:
			palabra = random.choice(palabras_posibles_2)
			pala = pilas.actores.Texto(palabra, x=pilas.azar(-240,240), y=230)
			pala.y=[-260],7
			pala.rotacion=[360],2

		creadas.append(pala.texto)

		indice_palabras += 1

		def borrar():
			if pala.y < -250:
				creadas.remove(pala.texto)
				pala.eliminar()
				tarea_borrar.terminar()

			elif entrada.texto == pala.texto:
				def matar():
					pala.aprender('puedeexplotar')
					pala.eliminar()
					puntos.aumentar()

				creadas.remove(pala.texto)
				pilas.tareas.una_vez(0,matar)#por si hace falta retrasarlo
				entrada.texto=("")
				tarea_borrar.terminar()

		tarea_borrar = pilas.tareas.siempre(0.2, borrar)

	else:
		tarea_crear.terminar()
		pilas.avisar('Fin del Nivel  ' + str(nivel))
		pilas.tareas.una_vez(7, final_de_nivel)

def final_de_nivel():
	tex1 = pilas.actores.Texto(u"Tu puntuación:",y=200, magnitud=30)
	tex1.color=pilas.colores.rojo
	tex2 = pilas.actores.Texto(str(puntos.valor), y= 150, magnitud=25)
	tex2.color = pilas.colores.Color(30,200,30)

tarea_crear = pilas.tareas.siempre(2, crear_palabra)

pilas.ejecutar()
1 me gusta

def al_pulsar_tecla(tecla):
print(tecla)

pilas.eventos.pulsa_tecla.conectar(al_pulsar_tecla)

Me impresiona como pilas va creciendo e incorporándose en la educación.
Gracias @jordinur
Saludos

No creo haber podido darme cuenta de eso pero a medida que le vaya agarrandole la mano, iré afinando el ojo. Llevo menos de un mes viendo esporadicamente pilas y su ayuda es invaluable.

Saludos :wink:

Mira, es muy fácil:

En vez de crear un método “general” en el que se almacenan todas las palabras en una lista, y luego se comparan las palabras de esa lista con lo que el player escribe (como hizo Hugo), yo despistadamente y casi sin querer incluí el método de “comparar y si es el caso matar” en la misma creación de cada una de las palabras.

Entonces, cada palabra se compara ella misma con el texto del player, lo que sobrecarga un tanto el “peso de ejecución” (o si lo prefieres y para se más técnicamente correcto, el uso del procesador).

Seguramente mi método es menos eficiente, pero (como en otros juegos que hice anteriormente) me resulta mucho más entendible sencillo y consistente hacerlo de esta manera. :blush:

1 me gusta

> lo que sobrecarga un tanto el "peso de ejecución"
Te entiendo ya que me llamaron la atención en tal sentido :blush:
:sweat_smile:

Gracias @jordinur
Gracias @hugoruscitti
Aprobé la Materia Muchas gracias por su ayuda.
Se que les he pedido mucho, pero me he dado cuento que las palabras que salen de pantalla no se eliminan del todo y que cuente como restar vidas
Traté de resolverlo pero sin éxito
No pude ni incluir el código de borrar del juego de jordinur ,
vere si encuentro algo en la web

class EscenaJuego(pilasengine.escenas.Escena):

    def iniciar(self):
        self.pilas.fondos.Galaxia(dy=-5)
        self.pilas.tareas.siempre(3, self._crear_un_actor_texto)

###############################################
        self.entrada = pilas.interfaz.IngresoDeTexto(ancho = 630)
        self.entrada.texto =("")
        self.entrada.y =-255
        self.crear_ingreso_de_texto()
####_____Correctos____#############################
        ###_revisar_textos_a_eliminar  Continua contador activo correcto###
        self.puntaje = pilas.actores.Puntaje(color="amarillo") #self
        self.puntaje.x = -150 #self
        self.puntaje.y = -184 #self
        self.puntaje.valor = 0 #añadido
        self.correctosaparecer=pilas.actores.Texto("Correctos:")
        self.correctosaparecer.x=-220
        self.correctosaparecer.y=-184
        self.crear_ingreso_de_texto()

####_____Vidas____#################################        
        self.vida = pilas.actores.Puntaje()
        self.vida.x = -150
        self.vida.y = -112
        self.vida.color = "verde"
        self.vida.aumentar(10)
        self.vidasaparecer=pilas.actores.Texto("Vidas:")
        self.vidasaparecer.x = -195
        self.vidasaparecer.y = -112
###############################################        
        self.textos_en_pantalla = []

Mil Gracias por su ayuda. En cuanto afine detalles lo compartiré para que tengan un ejemplo mas en la comunidad :wink:

Buenas, @javibautista !

Que bueno que aprobaras :smile:

Se hace difícil contestarte con tan poco código. No veo como son creadas las palabras, si son una class o no…

pero lo más fácil parece crear una def actualizar(self): dentro de la escenajuego

la def actualizar en pilas se “actualiza” 60 veces por segundo, lo que la convierte en ideal para controlar posiciones continuamente mientras el juego está activo.

entonces sería algo parecido a esto (a modo de ejemplo):

def actualizar(self):
        if self.palabra_creada.y <= -260:
                self.palabra_creada.eliminar()
                self.contador_de_vidas.reducir(1)
        else:
                pass #( o cualquier otro código que quieras incluir)

Un saludo :wink:

1 me gusta

es la misma del Post no le modifique casi nada


# -*- encoding: utf-8 -*-
import pilasengine
import os
import random

pilas = pilasengine.iniciar()

#cancion_de_fondo = pilas.musica.cargar('Combo_Breaker_Japan.mp3')
#cancion_de_fondo.reproducir()

### Algunas funciones para el juego ###
###def lista_palabras()
    


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

#"""class IngresoTexto(pilasengine.interfaz.ingreso_de_texto):"""

def iniciar_juego():
    pilas.escenas.EscenaJuego()


def records():
    pilas.escenas.EscenaRecords()

def salir_del_juego():
    pilas.terminar()
    cancion_de_fondo.detener()
	

class TextoEnemigo(pilasengine.actores.Texto):

    def __init__(self, *k, **kw):
        pilasengine.actores.Texto.__init__(self, *k, **kw)
        self.post_iniciar()
    
    def post_iniciar(self):

        self.x = pilas.azar(-200, 200)
        self.y = 290
        self.velocidad = pilas.azar(10, 11) / 5.0

    def actualizar(self):
        self.y -= self.velocidad

        # Elimina el objeto cuando sale de la pantalla.
        if self.y < -300:
            self.eliminar()


	

	
class EscenaMenu(pilasengine.escenas.Escena):

    def iniciar(self):
        MenuPrincipal = pilas.fondos.Tarde()
        mennu = pilas.actores.Menu([('Iniciar juego', iniciar_juego),
		                            ('Records', records),
									('Salir', salir_del_juego)])
        mennu.color = "amarillo"
        mennu.escala =1.3
		

        self._crear_el_titulo_del_juego()


    def _crear_el_titulo_del_juego(self):
        titulo = self.pilas.actores.Texto("MATA PALABRAS", magnitud=30, y=50)
        titulo.y = 300
        titulo.rotacion = 30
        titulo.y = [100], 1
        titulo.rotacion = [0], 1.2


        
listas = ["BAUTISTA","SILLA","MURCIELAGO","MESA",
          "PROGRAMA","FACTURA","ARQUITECTURA","CARA"]


        

class EscenaJuego(pilasengine.escenas.Escena):

    def iniciar(self):
        self.pilas.fondos.Galaxia(dy=-5)
        #fondo = pilas.fondos.Galaxia(dy=-5)
        self.pilas.tareas.siempre(3, self._crear_un_actor_texto)
        #self.pilas.eventos.click_de_mouse.conectar(self._cuando_hace_click)
        self.puntaje = pilas.actores.Puntaje(290, 200, color="blanco")
        self.crear_ingreso_de_texto()
        
####_____Vidas____#################################        
        self.vida = pilas.actores.Puntaje()
        self.vida.x = -150
        self.vida.y = -112
        self.vida.color = "verde"
        self.vida.aumentar(10)
        self.vidasaparecer=pilas.actores.Texto("Vidas:")
        self.vidasaparecer.x = -195
        self.vidasaparecer.y = -112
###############################################        
        self.textos_en_pantalla = []

		
    def _crear_un_actor_texto(self):
        #actor = TextoEnemigo(pilas, texto="BAUTISTA")
        #enemigos.agregar(actor)
        hasta = len(listas)
        texto = listas[pilas.azar(0, hasta-1)]
        actor = self.pilas.actores.TextoEnemigo(texto)
        self.textos_en_pantalla.append(actor)

    def crear_ingreso_de_texto(self):
        self.ingreso = self.pilas.interfaz.IngresoDeTexto("", y=-200)

        self.tareas.siempre(0.2, self._revisar_textos_a_eliminar)
        
    def _revisar_textos_a_eliminar(self):
        for actor in self.textos_en_pantalla:
            if actor.esta_eliminado():
                continue
            #print([actor.texto], "-", [self.ingreso.texto])
            if self.ingreso.texto and str(actor.texto).lower() in str(self.ingreso.texto).lower():
                self.ingreso.texto = ""
                self.textos_en_pantalla.remove(actor)
                #self.pilas.actores.Explosion(actor.x, actor.y)
                actor.eliminar()
                print("Eliminando actor:", actor.texto)
        



class TextoEnemigo(pilasengine.actores.Texto):

    def __init__(self, *k, **kw):
        pilasengine.actores.Texto.__init__(self, *k, **kw)
        self.post_iniciar()
    
    def post_iniciar(self):

        self.x = pilas.azar(-200, 200)
        self.y = 290
        self.velocidad = pilas.azar(10, 11) / 5.0

    def actualizar(self):
        self.y -= self.velocidad

        # Elimina el objeto cuando sale de la pantalla.
        if self.y < -250:
            self.eliminar()



                
class EscenaRecords(pilasengine.escenas.Escena):

    def iniciar(self):
        fondoh = pilas.fondos.Noche()
        #fondoh.imagen = pilas.imagenes.cargar("EscenaRecords.png")
        menuu = pilas.actores.Menu([('Volver al menu', volveralmenu)])
        menuu.y = -200        


## Vinculamos todas las escenas.
pilas.escenas.vincular(EscenaMenu)
pilas.escenas.vincular(EscenaJuego)
pilas.escenas.vincular(EscenaRecords)


## Vinculamos los actores Personalizados
#pilas.actores.vincular(BotonVolver)
pilas.actores.vincular(TextoEnemigo)
#pilas.actores.vincular(ActorEliminado)
#pilas.actores.vincular(IngresoTexto)


# Se inicia la escena principal.
#pilas.escenas.EscenaMenu()
pilas.escenas.EscenaJuego()


pilas.ejecutar()

Veo que la class texto_enemigo ya tiene una def actualizar donde se define que las palabras se eliminen al llegar abajo de la pantalla. Estás seguro de que no se eliminan? porque en teoria sí deberían eliminarse… :dizzy_face:

Si lo que quieres es que al eliminarse resten vidas, anula ese código de la def actualizar de texto_enemigo y adapta el que te hice antes de ejemplo en la def actualizar de la escena.

Un saludo :wink:

Buenas, @javibautista
revisando un poco este código último que mandaste me doy cuenta de que has creado dos veces la class textoenemigo. Quizás es eso lo que te está dando problemas de eliminación de las palabras?
Borra una de las dos class textoenemigo, a ver si así se soluciona…
Un saludo :wink: