Juego Matematicas

Muchas Gracias @jordinur lo probaré, si tengo alguna duda, te lo haré saber :wink:

Tengo listo mi menu, en donde en la opcion iniciar

tengo el juego:

coding: utf-8

import pilasengine
import random
import sys

sys.path.insert(0, “…”)
pilas = pilasengine.iniciar(titulo=“Pasar por escenas con logica”)

pilas.fondos.Noche()
nombre = ‘’

puntaje = pilas.actores.Puntaje(color=‘blanco’)
puntaje.x = -300
puntaje.y = 220

def reiniciar():
# Obtiene todos los actores de la pantalla.
actores = pilas.actores.listar_actores()

# Elimina todos los actores excepto el fondo y el puntaje
for actor in actores:
    if actor not in [puntaje, pilas.escena.fondo]:
        actor.eliminar()

# Genera una pregunta nueva
crear_una_nueva_pregunta()

def crear_una_nueva_pregunta():
#PREGUNTA

preg1 = pilas.azar(20,40)
preg2 = pilas.azar(0,20)
pregunta = pilas.actores.Texto("Cuanto es: " + str(preg1) + " - " + str(preg2),
            y=180,magnitud=25)

#DEFINO LAS CAJAS
caja1 = pilas.actores.Actor(x = -200, y = 70)
caja1.imagen = "caja.png"
caja1.escala = 2
caja1.esverdadera = False


caja2 = pilas.actores.Actor(x = 0, y = 70)
caja2.imagen = "caja.png"
caja2.escala = 2
caja2.esverdadera = False



caja3 = pilas.actores.Actor(x = 200, y = 70)
caja3.imagen = "caja.png"
caja3.escala = 2
caja3.esverdadera = False


#DEFINO RESPUESTAS
rta_1 = pilas.actores.Texto("",x=-200, y=70)
rta_2 = pilas.actores.Texto("",x = 0, y = 70)
rta_3 = pilas.actores.Texto("",x = 200, y = 70)

    #caja verdadera
cajas_posibles = [caja1,caja2,caja3]
textos_posibles = [rta_1,rta_2,rta_3]
indiceok = pilas.azar(0,2)
respuesta_verdadera = cajas_posibles[indiceok]
respuesta_verdadera.esverdadera = True
texto_de_respuestaok = textos_posibles[indiceok]
texto_de_respuestaok.texto = str(preg1-preg2)
   #cajas falsas

if caja1.esverdadera:
    rta_2.texto = str(pilas.azar(0,100))
    rta_3.texto = str(pilas.azar(0,100))
elif caja2.esverdadera:
        rta_1.texto = str(pilas.azar(0,100))
        rta_3.texto = str(pilas.azar(0,100))
elif caja3.esverdadera:
        rta_1.texto = str(pilas.azar(0,100))
        rta_2.texto = str(pilas.azar(0,100))


#ACA EL MONO

mono = pilas.actores.Mono(y=-150)
mono.aprender(pilas.habilidades.Arrastrable)


#COLISIONES
cajas = [caja1,caja2,caja3]
pilas.colisiones.agregar(mono,cajas,respuesta)

def respuesta(mono, caja):
if caja.esverdadera:
mono.decir(“MUY BIEN”)

    # Genera una estrella para mostrar que contesto
    # bien
    estrella = pilas.actores.Estrella()
    estrella.x = caja.x
    estrella.y = caja.y
    estrella.escala = 0.2
    estrella.escala = [2, 1] * 2

    # aumenta el puntaje
    puntaje.aumentar()

    # Reinicia el juego pasados los 2 segundos.
    pilas.tareas.una_vez(2, reiniciar)
else:
    mono.decir("Vuelve a Intentar")
    pilas.camara.vibrar()
    caja.eliminar()

crear_una_nueva_pregunta()

pilas.ejecutar()

como puedo hacer para cambiar a otra escena de multiplicacion

#multiplicacion

puntaje = pilas.actores.Puntaje(color=‘blanco’)
puntaje.x = -300
puntaje.y = 220

def reiniciar():
# Obtiene todos los actores de la pantalla.
actores = pilas.actores.listar_actores()

# Elimina todos los actores excepto el fondo y el puntaje
for actor in actores:
    if actor not in [puntaje, pilas.escena.fondo]:
        actor.eliminar()

# Genera una pregunta nueva
crear_una_nueva_pregunta()

def crear_una_nueva_pregunta():
#PREGUNTA

preg1 = pilas.azar(0,10)
preg2 = pilas.azar(0,10)
pregunta = pilas.actores.Texto("Cuanto es: " + str(preg1) + " x " + str(preg2),
            y=180,magnitud=25)

#DEFINO LAS CAJAS
caja1 = pilas.actores.Actor(x = -200, y = 70)
caja1.imagen = "caja.png"
caja1.escala = 2
caja1.esverdadera = False


caja2 = pilas.actores.Actor(x = 0, y = 70)
caja2.imagen = "caja.png"
caja2.escala = 2
caja2.esverdadera = False



caja3 = pilas.actores.Actor(x = 200, y = 70)
caja3.imagen = "caja.png"
caja3.escala = 2
caja3.esverdadera = False


#DEFINO RESPUESTAS
rta_1 = pilas.actores.Texto("",x=-200, y=70)
rta_2 = pilas.actores.Texto("",x = 0, y = 70)
rta_3 = pilas.actores.Texto("",x = 200, y = 70)

    #caja verdadera
cajas_posibles = [caja1,caja2,caja3]
textos_posibles = [rta_1,rta_2,rta_3]
indiceok = pilas.azar(0,2)
respuesta_verdadera = cajas_posibles[indiceok]
respuesta_verdadera.esverdadera = True
texto_de_respuestaok = textos_posibles[indiceok]
texto_de_respuestaok.texto = str(preg1*preg2)
   #cajas falsas

if caja1.esverdadera:
    rta_2.texto = str(pilas.azar(0,100))
    rta_3.texto = str(pilas.azar(0,100))
elif caja2.esverdadera:
        rta_1.texto = str(pilas.azar(0,100))
        rta_3.texto = str(pilas.azar(0,100))
elif caja3.esverdadera:
        rta_1.texto = str(pilas.azar(0,100))
        rta_2.texto = str(pilas.azar(0,100))


#ACA EL MONO

mono = pilas.actores.Mono(y=-150)
mono.aprender(pilas.habilidades.Arrastrable)


#COLISIONES
cajas = [caja1,caja2,caja3]
pilas.colisiones.agregar(mono,cajas,respuesta)

def respuesta(mono, caja):
if caja.esverdadera:
mono.decir(“MUY BIEN”)

    # Genera una estrella para mostrar que contesto
    # bien
    estrella = pilas.actores.Estrella()
    estrella.x = caja.x
    estrella.y = caja.y
    estrella.escala = 0.2
    estrella.escala = [2, 1] * 2

    # aumenta el puntaje
    puntaje.aumentar()

    # Reinicia el juego pasados los 2 segundos.
    pilas.tareas.una_vez(2, reiniciar)
else:
    mono.decir("Vuelve a Intentar")
    pilas.camara.vibrar()
    caja.eliminar()

crear_una_nueva_pregunta()

Adicionalmente tengo 3 escenas más de juego quisiera saber como pasar de una escena a otra

Buenas, @JuanGallardo !

Lo ideal en este caso seria dividir el juego en ESCENAS:

1 escena de menu
4 escenas de preguntas(suma, resta, multiplicacion, division)
alguna escena más según tu creas necesario (instrucciones, puntaje final, etc)

puedes consultar este tutorial sobre creación de menús y escenas:

En ese tutorial entre otras cosas se explica como crear un botón de retorno al menú, que es una de las cosas que preguntabas (también se puede usar para pasar a otra escena que tu creas necesaria)

Sin duda tu juego es ambicioso, y el crear las escenas te va a traer nuevos retos y tener que reformar en bastantes puntos tu código, pero realmente creo que el esfuerzo te va a valer mucho la pena, por que el juego quedaría de 10. :smile:

No dudes en volver a comentar cualquier otra duda que te surja, estaremos atentos a tus progresos!

Un abrazo :wink:

Buenas tardes @jordinur, el menu lo tengo listo:
Tiene iniciar (que sería el juego)
Instrucciones(está listo)
Puntaje final (el cual irá a un txt)
salir

En iniciar, ya está vinculado con la escena de suma, lo que deseo es una ayuda para vincular, de suma a resta, de resta a multiplicación, de multiplicación a operaciones combinadas.
Cada una de las operaciones matemáticas lo tengo trabajado de manera independiente, mi problema es al momento de unir todo para que de una escena vaya a otra.
Solo ese es el problema en mi menu.

Buenas, @JuanGallardo !

Me temo no entenderte… Me parece entender que ya tienes el juego dividido en escenas. Si es así y si lo que quieres es que vaya de una escena a otra, lo puedes hacer implementando un boton en cada escena, para que al pulsarlo te lleve a la escena siguiente…

En el tutorial se explica como crear un boton y que te lleve a la escena que quieras ir

class EscenaDeLaSuma(pilasengine.escenas.Escena):
	def iniciar(self):
		self.Boton_IrAResta =pilas.interfaz.Boton('Ir a la Resta')
		self.Boton_IrAResta.y = -100
		
		#conectamos el boton...
		self.Boton_IrAResta.conectar(self.Ir_a_resta)
		
		#con la funcion que nos lleva a la escena de la resta:
	def Ir_a_resta(self):	
		pilas.escenas.EscenaDeLaResta()

y al pulsar el boton el player irá de la escena de la suma a la escena de la resta…

Espero que sea esto lo que estás preguntando :slight_smile:

Un abrazo.

Si gracias @jordinur, voy a implementarlo, a ver como me va, cualquier duda te haré saber.

Buenas noches, necesito ayuda para iniciar el juego de matematicas antes mencionado, ingresando un usuario, y luego al dar click en el boton ingresar, este me lleve a la escena de menu con el que cuento con 4 opciones:
Iniciar
Tutorial
Puntaje
Salir

He visto los ejemplos anteriores de ingreso de usuario pero se me presenta dificultad cuando quiero que al ingresar un usuario este me derive a la escena de menu. Espero alguna ayuda. Gracias.

Buenas, @JuanGallardo !

Podrias aportar algo de código de lo que tengas hasta ahora para ver cómo se podria hacer?

Es que se hace difícil sin ver cómo tienes el juego montado.

Pero por lo que explicas, deberias crear una escena de ingreso de nombre, esta escena deberia ser la primera en activarse. Sin ver el código no puedo ayudarte más.

Un saludo :wink:

Buenos días @jordinur este es el código que tengo hasta el momento y si quisiera una escena de ingresar usuario y luego ingrese a la escena de menu.
Otra consulta, es posible manejar base de datos con pilas engine?. Por ejemplo si quisiera que mi juego ingrese datos el usuario (en este caso el niño), como puedo hacer para que el docente también pueda ingresar sus datos y pueda ver cuanto de puntaje hizo cada niño en su aula.

# coding: utf-8
import pilasengine
import random
import sys

sys.path.insert(0, "..")
pilas = pilasengine.iniciar(titulo="Pasar por escenas con logica")

nombre = ' '
         
tiempo = 5
contador = pilas.actores.Texto("...")
contador.x = -295
contador.y = 190

vueltas = 0
contavueltas = pilas.actores.Texto("...")
contavueltas.x = -295
contavueltas.y = 165

puntaje = pilas.actores.Puntaje(color='negro')
puntaje.x = -300
puntaje.y = 220

  
class PantallaInstrucciones(pilasengine.escenas.Escena):
    
    def iniciar(self):
        
        self.fondo = self.pilas.fondos.Fondo("fondo_instrucciones.jpg")
        
        mono = pilas.actores.Mono()
        mono.decir("Hola, me llamo Larry!!!")
        mono.x = 150
        mono.y = -180

        #pilas.escenas.Normal()
      
        texto= pilas.actores.Texto("*INSTRUCCIONES SOBRE EL JUEGO*")
        texto.y= 200
        texto.color= pilas.colores.amarillo
        expli= pilas.actores.Texto("Bienvenido a PLAYING MATH")
        expli.y=150          
        expli1= pilas.actores.Texto("A continuacion Larry te ayudara a resolver ")
        expli1.y=120
        expli2= pilas.actores.Texto("diversos ejercicios de matematicas")
        expli2.y= 90                    
        expli3= pilas.actores.Texto(" para ello, en cada ejercicio ")
        expli3.y= 60                                                    
        expli4= pilas.actores.Texto("deberas arrastrar a Larry con el mouse")                                                                                                
        expli4.y=30                                                                                                                                            
        expli5= pilas.actores.Texto("hacia la respuesta correcta,")
        expli5.y= 0
        expli6= pilas.actores.Texto("mientras mas aciertos")
        expli6.y=-30
        expli7= pilas.actores.Texto("mayor puntaje.")
        expli7.y= -60
        mensaje= pilas.actores.Texto("**QUE TE DIVIERTAS!**")
        mensaje.y= -100
        mensaje.color= pilas.colores.rojo
        mensaje.escala= 1.5
        volver= pilas.interfaz.Boton("volver")
        volver.y= -200
        volver.x= 260
        
        volver.conectar(self.volver_a_menu) #Conectamos el boton a una def
        
    def volver_a_menu(self): #se ejecuta al pulsar el boton.
		
	pilas.escenas.PantallaMenu()
class PantallaBienvenida(pilasengine.escenas.Escena):

    def iniciar(self):
        self.fondo = self.pilas.fondos.Noche()
        
        #defino puntaje
        puntaje = pilas.actores.Puntaje(color='negro')
        puntaje.x = -300
        puntaje.y = 220
        crear_una_nueva_pregunta()
        pilas.eventos.pulsa_tecla_escape.conectar(self.regresar)

    def ejecutar(self):
        pass
        
    def regresar(self, evento):
        pilas.escenas.PantallaMenu()

class PantallaMenu(pilasengine.escenas.Escena):
    
    def iniciar(self):
        	
        self.fondomenu = self.pilas.fondos.Fondo("fondomenu_nuevo.jpg")
        
        mono = pilas.actores.Mono()
        mono.decir("Bienvenido al Menu")
        mono.x = 180
        mono.y = 120
        
        pilas.actores.Menu(
        [
            ('Iniciar juego', iniciar_juego),
            ('Como jugar', como_jugar),
            ('Salir', salir_del_juego),
        ])

        
def volver_a_menu(self): #se ejecuta al pulsar el boton.
		
	pilas.escenas.PantallaMenu()



def como_jugar():
    print("Sigo las instrucciones")
    pilas.escenas.PantallaInstrucciones()
    
def iniciar_juego():

    print("Arrastrar a Larry")
    pilas.escenas.PantallaBienvenida()
    
    pilas.avisar('Arrastra a Larry a la respuesta correcta')


puntaje = pilas.actores.Puntaje(color='blanco')
puntaje.x = -300
puntaje.y = 220


def reiniciar():
    # Obtiene todos los actores de la pantalla.
    actores = pilas.actores.listar_actores()

    # Elimina todos los actores excepto el fondo y el puntaje
    for actor in actores:
        if actor not in [puntaje, pilas.escena.fondo]:
            actor.eliminar()

    # Genera una pregunta nueva
    crear_una_nueva_pregunta()

def crear_una_nueva_pregunta():
    #PREGUNTA

    preg1 = pilas.azar(0,20)
    preg2 = pilas.azar(0,20)
    pregunta = pilas.actores.Texto("Cuanto es: " + str(preg1) + " + " + str(preg2),
                y=180,magnitud=25)

                
    #DEFINO LAS CAJAS
    caja1 = pilas.actores.Actor(x = -200, y = 70)
    caja1.imagen = "caja.png"
    caja1.escala = 2
    caja1.esverdadera = False


    caja2 = pilas.actores.Actor(x = 0, y = 70)
    caja2.imagen = "caja.png"
    caja2.escala = 2
    caja2.esverdadera = False



    caja3 = pilas.actores.Actor(x = 200, y = 70)
    caja3.imagen = "caja.png"
    caja3.escala = 2
    caja3.esverdadera = False


    #DEFINO RESPUESTAS
    rta_1 = pilas.actores.Texto("",x=-200, y=70)
    rta_2 = pilas.actores.Texto("",x = 0, y = 70)
    rta_3 = pilas.actores.Texto("",x = 200, y = 70)

        #caja verdadera
    cajas_posibles = [caja1,caja2,caja3]
    textos_posibles = [rta_1,rta_2,rta_3]
    indiceok = pilas.azar(0,2)
    respuesta_verdadera = cajas_posibles[indiceok]
    respuesta_verdadera.esverdadera = True
    texto_de_respuestaok = textos_posibles[indiceok]
    texto_de_respuestaok.texto = str(preg1+preg2)

         #cajas falsas

    if caja1.esverdadera:
        rta_2.texto = str(pilas.azar(0,100))
        rta_3.texto = str(pilas.azar(0,100))
    elif caja2.esverdadera:
            rta_1.texto = str(pilas.azar(0,100))
            rta_3.texto = str(pilas.azar(0,100))
    elif caja3.esverdadera:
            rta_1.texto = str(pilas.azar(0,100))
            rta_2.texto = str(pilas.azar(0,100))


    #ACA EL MONO

    mono = pilas.actores.Mono(y=-150)
    mono.aprender(pilas.habilidades.Arrastrable)


    #COLISIONES
    cajas = [caja1,caja2,caja3]
    pilas.colisiones.agregar(mono,cajas,respuesta)



def respuesta(mono, caja):
    if caja.esverdadera:
        mono.decir("MUY BIEN")

        # Genera una estrella para mostrar que contesto
        # bien
        estrella = pilas.actores.Estrella()
        estrella.x = caja.x
        estrella.y = caja.y
        estrella.escala = 0.2
        estrella.escala = [2, 1] * 2

        # aumenta el puntaje
        puntaje.aumentar()

        # Reinicia el juego pasados los 2 segundos.
        pilas.tareas.una_vez(2, reiniciar)
    else:
        mono.decir("Vuelve a Intentar")
        pilas.camara.vibrar()
        caja.eliminar()


crear_una_nueva_pregunta()


def salir_del_juego():
    print("Tengo que salir...")
    pilas.terminar()
    

pilas.escenas.vincular(PantallaMenu)
pilas.escenas.vincular(PantallaInstrucciones)
pilas.escenas.vincular(PantallaBienvenida)

pilas.escenas.PantallaMenu()

pilas.ejecutar()

Buenas, @JuanGallardo !

En su dia ya se respondió este tema sobre ingresar el nombre del usuario

En tu caso, en vez de hacer el ingreso del nombre en la escenaMenu deberias crear una nueva escena llamada por ejemplo class EscenaIngreso(pilasengine.escenas.Escena). Después deberias vincularla, y llamarla al final del código para que sea la que se active al iniciar el juego.

class EscenaIngreso(pilasengine.escenas.Escena): 
    def iniciar(self):
        self.valor1 = pilas.interfaz.IngresoDeTexto()
        self.valor1.texto =u'Nombre?'
    
        botonInicio = pilas.interfaz.Boton('Iniciar Juego')
        botonInicio.y = -100
        botonInicio.conectar(self.al_pulsar_el_boton)
    
    def obtener_valor(self, actor_texto):
        return str(actor_texto.texto)  # lo retorna

    def al_pulsar_el_boton(self):
        nombre = self.obtener_valor(self.valor1)
        
        pilas.escenas.EscenaMenu(nombre)    # pasas el nombre a la otra escena

class EscenaMenu(pilasengine.escenas.Escena):
    def iniciar(self, nombre):   # recoges el nombre pasado de la escena anterior
        texto_Hola = pilas.actores.Texto('Hola,')
        texto_Hola.y = 50
        texto_nombre = pilas.actores.Texto(nombre) 
        #AQUI EL RESTO DE TU CODIGO DE LA ESCENA MENU

En cuanto al tratamiento de base de datos a buen seguro debe poder hacerse, pero eso ya se escapa totalmente a mis conocimientos. Quizás @hugoruscitti pueda contestarte en cuanto le sea posible conectarse.

Un saludo ! :wink:

Buenos dias @jordinur necesito tu apoyo con el siguiente codigo, tengo problemas con el ingreso de nombre, con el puntaje y la parte de resultado de puntaje (def ganaste y def perdiste).

 ###coding utf8###

import pilasengine
pilas = pilasengine.iniciar()
class EscenaMenu(pilasengine.escenas.Escena):
	def iniciar(self):
		self.fondo = self.pilas.fondos.Fondo("fondo.jpg")
		
		dialogo=pilas.actores.Dialogo()
		self.mono1 = pilas.actores.Mono()
		self.mono1.x=180
	
		dialogo.decir(self.mono1, "Presiona en mi")
		dialogo.decir(self.mono1, "Si respondes 20 veces bien ganas, si respondes 3 veces mal pierdes")
								  

		dialogo.comenzar()
		
		self.Mi_Menu = pilas.actores.Menu(
			[
				(u"Jugar", self.Ir_al_juego),
				(u"Ayuda", self.Ayuda),
				(u"Salir", self.Salir_de_Pilas)
			])
		
		Nombre_de_juego = pilas.actores.Texto(u"Menu Principal")
		Nombre_de_juego.color = pilas.colores.amarillo
		Nombre_de_juego.y = 50

	def actualizar(self):
		pass
		
	def Ayuda(self):
		pilas.escenas.EscenaAyuda()
		
	def Salir_de_Pilas(self): 
		pilas.terminar()	
		
	def Ir_al_juego(self): 
		pilas.escenas.EscenaJuego()
		
class EscenaAyuda(pilasengine.escenas.Escena):
	def iniciar(self):
		self.fondo_juego=pilas.fondos.Noche()
		self.fondo_juego.imagen="fondo_instrucciones.jpg"
		self.Boton_Volver =pilas.interfaz.Boton("Volver al Menu")
		self.Boton_Volver.y = 220
		self.Boton_Volver.x = 250
		self.Boton_Volver.conectar(self.Volver)
		
	def Volver(self):	
		pilas.escenas.EscenaMenu()
		
	def actualizar(self):
		pass	

class EscenaJuego(pilasengine.escenas.Escena):
        
            def iniciar(self):
            self.nombre=raw_input("Ingrese su nombre: ")
           
             self.fondo= self.pilas.fondos.Noche()
	#Defino Puntaje
	self.puntaje = pilas.actores.Puntaje(color="rojo") #self
	self.puntaje.x = -150 #self
	self.puntaje.y = -190 #self
	self.puntaje.valor = 0 #añadido
	self.correctosaparecer=pilas.actores.Texto("Correctos:")
	self.correctosaparecer.x=-220
	self.correctosaparecer.y=-190
		
	self.error=pilas.actores.Puntaje(color="rojo")
	self.error.valor=0
	self.error.x=-150
	self.error.y=-220
	self.incorrectosaparecer=pilas.actores.Texto("Incorrectos:")
	self.incorrectosaparecer.x=-230
	self.incorrectosaparecer.y=-220
		
	self.mono = pilas.actores.Mono()
	self.mono.escala = 0.8 
	self.mono.aprender('arrastrable') 
	self.mono.aprender('MoverseConElTeclado') 
	self.mono.decir("Bienvenido/a "+ self.nombre + " puedes arrastrarme")
	self.mono.x=[0,200],1
		
	self.Boton_Volver =pilas.interfaz.Boton("Volver al Menu")
	self.Boton_Volver.y = -220
	self.Boton_Volver.x = 250
	self.Boton_Volver.conectar(self.Volver)
		
		

    def ejecutar(self):
        pass
    
    def regresar(self, evento):
        pilas.escenas.EscenaMenu()

    def crear_pregunta(self):
	suma_resta = pilas.azar(0,1)
	
	#Defino preguntas al azar
	self.preg1 = pilas.azar(25,50)
	self.preg2 = pilas.azar(0,25)
	
	if suma_resta == 0:
	    self.pregunta = pilas.actores.Texto("Cuanto es: " + str(self.preg1) + " + " + str(self.preg2),y=180,magnitud=25)
	else:    
	    self.pregunta = pilas.actores.Texto("Cuanto es: " + str(self.preg1) + " - " + str(self.preg2),y=180,magnitud=25)

	#DEFINO LAS CAJAS
	caja1 = pilas.actores.Actor(x = -200, y = 70)
	caja1.imagen = "caja.png"
	caja1.escala = 1.5
	caja1.esverdadera = False

	caja2 = pilas.actores.Actor(x = 0, y = 70)
	caja2.imagen = "caja.png"
	caja2.escala = 1.5
	caja2.esverdadera = False

	caja3 = pilas.actores.Actor(x = 200, y = 70)
	caja3.imagen = "caja.png"
	caja3.escala = 1.5
	caja3.esverdadera = False

	#DEFINO RESPUESTAS
	rta_1 = pilas.actores.Texto("",x=-200, y=70)
	rta_2 = pilas.actores.Texto("",x = 0, y = 70)
	rta_3 = pilas.actores.Texto("",x = 200, y = 70)

	#Cajas posibles
	Cajas_posibles = [caja1,caja2,caja3]
	textos_posibles = [rta_1,rta_2,rta_3]
	indiceok = pilas.azar(0,2)
	respuesta_verdadera = cajas_posibles[indiceok]
	respuesta_verdadera.esverdadera = True
	texto_de_respuestaok = textos_posibles[indiceok]

	if suma_resta == 0:
	    texto_de_respuestaok.texto = str(preg1+preg2)
	else:
	    texto_de_respuestaok.texto = str(preg1-preg2)


	#Cajas falsos
	if caja1.esverdadera:
	    rta_2.texto = str(pilas.azar(0,100))
	    rta_3.texto = str(pilas.azar(0,100))
	elif caja2.esverdadera:
	    rta_1.texto = str(pilas.azar(0,100))
	    rta_3.texto = str(pilas.azar(0,100))
	elif caja3.esverdadera:
	    rta_1.texto = str(pilas.azar(0,100))
	    rta_2.texto = str(pilas.azar(0,100))

	#ACA EL MONO 
	mono = pilas.actores.Mono(y=-150)
	mono.aprender(pilas.habilidades.Arrastrable)


	#COLISIONES
	cajas = [caja1, caja2, caja3]
	pilas.colisiones.agregar(mono, cajas, respuesta)

    def respuesta(mono, caja):
	if caja.esverdadera:
	    mono.decir("MUY BIEN!!!")

	    # Genera una estrella para mostrar que contesto
	    # bien
	    estrella = pilas.actores.Estrella()
	    estrella.x = caja.x
	    estrella.y = caja.y
	    estrella.escala = 0.2
	    estrella.escala = [2, 1] * 2

	    #Aumenta el puntaje
	    if self.puntaje.valor < 19:
		self.puntaje.aumentar(1)
		# Reinicia el juego pasados los 2 segundos.
		pilas.tareas.una_vez(2, self.reiniciar)
	    else:
		pilas.avisar("Haz Ganado!!!")
		self.puntaje.aumentar(1)
		# Vuelve al Menú pasados los 4 segundos.
		pilas.tareas.una_vez(4, self.regresar_menu)
	else:
	    cursor_disparo.decir("VUELVE A INTENTARLO!")
	    pilas.camara.vibrar()
	    caja.eliminar()
	    puntaje.reducir(1)

    def reiniciar(self):
	# Obtiene todos los actores de la pantalla.
	actores = pilas.actores.listar_actores()

	# Elimina todos los actores excepto el fondo y el puntaje
	for actor in actores:
	    if actor not in [self.puntaje, self.texto_puntos, pilas.escena.fondo]:
		actor.eliminar()

	# Genera una pregunta nueva
	self.crear_pregunta()
    
    def ganaste(self):
		actores = pilas.actores.listar_actores()

    # Elimina todos los actores excepto el fondo y el puntaje
		for actor in actores:
		if actor not in [self.mono]:
			actor.eliminar()
		self.fondo_juego=pilas.fondos.Noche()
		self.Boton_Volver =pilas.interfaz.Boton("Volver al Menu")
		self.Boton_Volver.y = 220
		self.Boton_Volver.x = 250
		self.Boton_Volver.conectar(self.Volver)
		self.puntajefinal=pilas.actores.Texto(str(self.puntaje.valor))
		self.puntajefinal.escala=2
		self.cartelfelicidades=pilas.actores.Texto("Felicidades "+self.nombre+" has ganado")
		self.cartelfelicidades.y=220
		self.cartelfelicidades=pilas.actores.Texto("Larry esta feliz")
		self.cartelfelicidades.y=150
		self.cartelpuntaje=pilas.actores.Texto("Tu puntaje es: ")
		self.cartelpuntaje.x=-100
		self.errorestotales=pilas.actores.Texto(str(self.error.valor))
		self.errorestotales.y=-100
		self.errorestotales.escala=2
		self.cartelerror=pilas.actores.Texto("Cantidad de errores: ")
		self.cartelerror.x=-150
		self.cartelerror.y=-100
		self.mono.sonreir()
	
	def perdiste(self):
		actores = pilas.actores.listar_actores()

    # Elimina todos los actores excepto el fondo y el puntaje
		for actor in actores:
			if actor not in [self.mono]:
				actor.eliminar()
		self.fondo_juego=pilas.fondos.Noche()
		self.Boton_Volver =pilas.interfaz.Boton("Volver al Menu")
		self.Boton_Volver.y = 220
		self.Boton_Volver.x = 250
		self.Boton_Volver.conectar(self.Volver)
		self.puntajefinal=pilas.actores.Texto(str(self.puntaje.valor))
		self.puntajefinal.escala=2
		self.cartelfelicidades=pilas.actores.Texto(self.nombre+ " PERDISTE :(")
		self.cartelfelicidades.y=220
		self.cartelfelicidades=pilas.actores.Texto("Larry se enfermo")
		self.cartelfelicidades.y=150
		self.cartelpuntaje=pilas.actores.Texto("Tu puntaje es: ")
		self.cartelpuntaje.x=-100
		self.errorestotales=pilas.actores.Texto(str(self.error.valor))
		self.errorestotales.y=-100
		self.errorestotales.escala=2
		self.cartelerror=pilas.actores.Texto("Cantidad de errores: ")
		self.cartelerror.x=-150
		self.cartelerror.y=-100
		self.mono.gritar()
		
	def Volver(self):	
		pilas.escenas.EscenaMenu()
		
	def actualizar(self):
		pass	
		

    def regresar_menu(self):
	pilas.escenas.EscenaMenu()
        
		                                             
pilas.escenas.vincular(EscenaMenu)
pilas.escenas.vincular(EscenaAyuda)
pilas.escenas.vincular(EscenaJuego)

pilas.escenas.EscenaMenu()
          
pilas.ejecutar()

Buenas, @JuanGallardo

Tengo que decirte que tu código presenta muchos errores de identación, lo que hace muy difícil buscar posibles errores. :cold_sweat:

Observo también que no has incluido mis recomendaciones sobre crear una escena para el ingreso del nombre, el cual ahora mismo es entrado con una raw_input…

En un examen “a vista” parece que falta la llamada al procedimiento def crear_pregunta(self). Sin esta llamada, aunque el juego se indexe correctamente y arranque, no se va a producir la pregunta.

Tambien se observa que falta un “self” en el procedimiento def respuesta(mono, caja):

def respuesta(self, mono, caja):

Prueba a corregir tu código para que quede correctamente indexado, y entonces podremos intentar buscar alternativas a tus dudas, ok? :wink:

Un saludo!

Buenas tardes, @jordinur gracias por tu apoyo, adjunto nuevamente las modificaciones que acabo de hacer a las observaciones

###coding utf8###

import pilasengine
pilas = pilasengine.iniciar()

class EscenaIngreso(pilasengine.escenas.Escena):
 def iniciar(self):
self.valor1 = pilas.interfaz.IngresoDeTexto()
self.valor1.texto =u'Nombre?'

botonInicio = pilas.interfaz.Boton('IniciarJuego')
botonInicio.y = -100
botonInicio.conectar(self.al_pulsar_el_boton)

def obtener_valor(self, actor_texto):
return str(actor_texto.texto)

def al_pulsar_el_boton(self):
nombre = self.obtener_valor(self.valor1)

pilas.escenas.EscenaMenu(nombre)

class EscenaMenu(pilasengine.escenas.Escena):
	def iniciar(self, nombre):
                texto_Hola = pilas.actores.Texto('Hola, ')
                texto_Hola.y = 50
                texto_nombre = pilas.actores.Texto(nombre)
		self.fondo = self.pilas.fondos.Fondo("fondo.jpg")
		
		dialogo=pilas.actores.Dialogo()
		self.mono1 = pilas.actores.Mono()
		self.mono1.x=180
	
		dialogo.decir(self.mono1, "Presiona en mi")
		dialogo.decir(self.mono1, "Si respondes 20 veces bien ganas, si respondes 3 veces mal pierdes")
								  

		dialogo.comenzar()
		
		self.Mi_Menu = pilas.actores.Menu(
			[
				(u"Jugar", self.Ir_al_juego),
				(u"Ayuda", self.Ayuda),
				(u"Salir", self.Salir_de_Pilas)
			])
		
		Nombre_de_juego = pilas.actores.Texto(u"Menu Principal")
		Nombre_de_juego.color = pilas.colores.amarillo
		Nombre_de_juego.y = 50

	def actualizar(self):
		pass
		
	def Ayuda(self):
		pilas.escenas.EscenaAyuda()
		
	def Salir_de_Pilas(self): 
		pilas.terminar()	
		
	def Ir_al_juego(self): 
		pilas.escenas.EscenaJuego()
		
class EscenaAyuda(pilasengine.escenas.Escena):
	def iniciar(self):
		self.fondo_juego=pilas.fondos.Noche()
		self.fondo_juego.imagen="fondo_instrucciones.jpg"
		self.Boton_Volver =pilas.interfaz.Boton("Volver al Menu")
		self.Boton_Volver.y = 220
		self.Boton_Volver.x = 250
		self.Boton_Volver.conectar(self.Volver)
		
	def Volver(self):	
		pilas.escenas.EscenaMenu()
		
	def actualizar(self):
		pass	

class EscenaJuego(pilasengine.escenas.Escena):
        
            def iniciar(self):
         
           
             self.fondo= self.pilas.fondos.Noche()
	#Defino Puntaje
	self.puntaje = pilas.actores.Puntaje(color="rojo") #self
	self.puntaje.x = -150 #self
	self.puntaje.y = -190 #self
	self.puntaje.valor = 0 #añadido
	self.correctosaparecer=pilas.actores.Texto("Correctos:")
	self.correctosaparecer.x=-220
	self.correctosaparecer.y=-190
		
	self.error=pilas.actores.Puntaje(color="rojo")
	self.error.valor=0
	self.error.x=-150
	self.error.y=-220
	self.incorrectosaparecer=pilas.actores.Texto("Incorrectos:")
	self.incorrectosaparecer.x=-230
	self.incorrectosaparecer.y=-220
		
	self.mono = pilas.actores.Mono()
	self.mono.escala = 0.8 
	self.mono.aprender('arrastrable') 
	self.mono.aprender('MoverseConElTeclado') 
	self.mono.decir("Bienvenido/a "+ self.nombre + " puedes arrastrarme")
	self.mono.x=[0,200],1
		
	self.Boton_Volver =pilas.interfaz.Boton("Volver al Menu")
	self.Boton_Volver.y = -220
	self.Boton_Volver.x = 250
	self.Boton_Volver.conectar(self.Volver)
		
		

    def ejecutar(self):
        pass
    
    def regresar(self, evento):
        pilas.escenas.EscenaMenu()

    def crear_pregunta(self):
	suma_resta = pilas.azar(0,1)
	
	#Defino preguntas al azar
	self.preg1 = pilas.azar(25,50)
	self.preg2 = pilas.azar(0,25)
	
	if suma_resta == 0:
	    self.pregunta = pilas.actores.Texto("Cuanto es: " + str(self.preg1) + " + " + str(self.preg2),y=180,magnitud=25)
	else:    
	    self.pregunta = pilas.actores.Texto("Cuanto es: " + str(self.preg1) + " - " + str(self.preg2),y=180,magnitud=25)

	#DEFINO LAS CAJAS
	self.caja1 = pilas.actores.Actor(x = -200, y = 70)
	self.caja1.imagen = "caja.png"
	self.caja1.escala = 1.5
	self.caja1.esverdadera = False

	self.caja2 = pilas.actores.Actor(x = 0, y = 70)
	self.caja2.imagen = "caja.png"
	self.caja2.escala = 1.5
	self.caja2.esverdadera = False

	self.caja3 = pilas.actores.Actor(x = 200, y = 70)
	self.caja3.imagen = "caja.png"
	self.caja3.escala = 1.5
	self.caja3.esverdadera = False

	#DEFINO RESPUESTAS
	self.rta_1 = pilas.actores.Texto("",x=-200, y=70)
	self.rta_2 = pilas.actores.Texto("",x = 0, y = 70)
	self.rta_3 = pilas.actores.Texto("",x = 200, y = 70)

	#Cajas posibles
	Cajas_posibles = [self.caja1,self.caja2,self.caja3]
	textos_posibles = [self.rta_1,self.rta_2,self.rta_3]
	indiceok = pilas.azar(0,2)
	respuesta_verdadera = cajas_posibles[indiceok]
	respuesta_verdadera.esverdadera = True
	texto_de_respuestaok = textos_posibles[indiceok]

	if suma_resta == 0:
	    texto_de_respuestaok.texto = str(self.preg1+self.preg2)
	else:
	    texto_de_respuestaok.texto = str(self.preg1-self.preg2)


	#Cajas falsos
	if self.caja1.esverdadera:
	    self.rta_2.texto = str(pilas.azar(0,100))
	    self.rta_3.texto = str(pilas.azar(0,100))
	elif self.caja2.esverdadera:
	    self.rta_1.texto = str(pilas.azar(0,100))
	    self.rta_3.texto = str(pilas.azar(0,100))
	elif caja3.esverdadera:
	    self.rta_1.texto = str(pilas.azar(0,100))
	    self.rta_2.texto = str(pilas.azar(0,100))

	#ACA EL MONO 
	self.mono = pilas.actores.Mono(y=-150)
	self.mono.aprender(pilas.habilidades.Arrastrable)


	#COLISIONES
	cajas = [self.caja1, self.caja2, self.caja3]
	pilas.colisiones.agregar(self.mono, cajas, self.respuesta)

    def respuesta(self, mono, caja):
	if caja.esverdadera:
	    mono.decir("MUY BIEN!!!")

	    # Genera una estrella para mostrar que contesto
	    # bien
	    estrella = pilas.actores.Estrella()
	    estrella.x = caja.x
	    estrella.y = caja.y
	    estrella.escala = 0.2
	    estrella.escala = [2, 1] * 2

	    #Aumenta el puntaje
	    if self.puntaje.valor < 19:
		self.puntaje.aumentar(1)
		# Reinicia el juego pasados los 2 segundos.
		pilas.tareas.una_vez(2, self.reiniciar)
	    else:
		pilas.avisar("Haz Ganado!!!")
		self.puntaje.aumentar(1)
		# Vuelve al Menú pasados los 4 segundos.
		pilas.tareas.una_vez(4, self.regresar_menu)
	else:
	    cursor_disparo.decir("VUELVE A INTENTARLO!")
	    pilas.camara.vibrar()
	    caja.eliminar()
	    puntaje.reducir(1)

    def reiniciar(self):
	# Obtiene todos los actores de la pantalla.
	actores = pilas.actores.listar_actores()

	# Elimina todos los actores excepto el fondo y el puntaje
	for actor in actores:
	    if actor not in [self.puntaje, self.texto_puntos, pilas.escena.fondo]:
		actor.eliminar()

	# Genera una pregunta nueva
	self.crear_pregunta()
    
    def ganaste(self):
		actores = pilas.actores.listar_actores()

    # Elimina todos los actores excepto el fondo y el puntaje
		for actor in actores:
		if actor not in [self.mono]:
			actor.eliminar()
		self.fondo_juego=pilas.fondos.Noche()
		self.Boton_Volver =pilas.interfaz.Boton("Volver al Menu")
		self.Boton_Volver.y = 220
		self.Boton_Volver.x = 250
		self.Boton_Volver.conectar(self.Volver)
		self.puntajefinal=pilas.actores.Texto(str(self.puntaje.valor))
		self.puntajefinal.escala=2
		self.cartelfelicidades=pilas.actores.Texto("Felicidades "+self.nombre+" has ganado")
		self.cartelfelicidades.y=220
		self.cartelfelicidades=pilas.actores.Texto("Larry esta feliz")
		self.cartelfelicidades.y=150
		self.cartelpuntaje=pilas.actores.Texto("Tu puntaje es: ")
		self.cartelpuntaje.x=-100
		self.errorestotales=pilas.actores.Texto(str(self.error.valor))
		self.errorestotales.y=-100
		self.errorestotales.escala=2
		self.cartelerror=pilas.actores.Texto("Cantidad de errores: ")
		self.cartelerror.x=-150
		self.cartelerror.y=-100
		self.mono.sonreir()
	
	def perdiste(self):
		actores = pilas.actores.listar_actores()

    # Elimina todos los actores excepto el fondo y el puntaje
		for actor in actores:
			if actor not in [self.mono]:
				actor.eliminar()
		self.fondo_juego=pilas.fondos.Noche()
		self.Boton_Volver =pilas.interfaz.Boton("Volver al Menu")
		self.Boton_Volver.y = 220
		self.Boton_Volver.x = 250
		self.Boton_Volver.conectar(self.Volver)
		self.puntajefinal=pilas.actores.Texto(str(self.puntaje.valor))
		self.puntajefinal.escala=2
		self.cartelfelicidades=pilas.actores.Texto(self.nombre+ " PERDISTE :(")
		self.cartelfelicidades.y=220
		self.cartelfelicidades=pilas.actores.Texto("Larry se enfermo")
		self.cartelfelicidades.y=150
		self.cartelpuntaje=pilas.actores.Texto("Tu puntaje es: ")
		self.cartelpuntaje.x=-100
		self.errorestotales=pilas.actores.Texto(str(self.error.valor))
		self.errorestotales.y=-100
		self.errorestotales.escala=2
		self.cartelerror=pilas.actores.Texto("Cantidad de errores: ")
		self.cartelerror.x=-150
		self.cartelerror.y=-100
		self.mono.gritar()
		
	def Volver(self):	
		pilas.escenas.EscenaMenu()
		
	def actualizar(self):
		pass	
		

    def regresar_menu(self):
	pilas.escenas.EscenaMenu()
        
pilas.escenas.vincular(EscenaIngreso)		                                      
pilas.escenas.vincular(EscenaMenu)
pilas.escenas.vincular(EscenaAyuda)
pilas.escenas.vincular(EscenaJuego)

pilas.escenas.EscenaMenu()

el def crear_pregunta(self) si está
y los self acabo de agregarlos a colisiones, respuesta

Este es el error que me sale
»
× # IndentationError:
× #
× # Traza del error (las llamadas mas recientes al final):
× # Archivo “C:\PILAS-~1\pilasengine\interprete\editor.py”,linea 646, en ejecutar
× # exec(contenido, self.interpreterLocals)
× # Archivo actual,linea 30
× # texto_Hola = pilas.actores.Texto(‘Hola,’)
× # ^
× # IndentationError: unexpected indent
× #

»

Ese es el tipo de error al que yo me referia, y que me hacía difícil revisar el código. Ese error es, simplemente, que hay algún espacio de más o de menos (o una tabulación) alrededor de la línea 30 de tu juego. Intenta eliminar todos los espacios innecesarios al principio y al final de las líneas [quote=“JuanGallardo, post:15, topic:1081”]

def iniciar(self, nombre):
                texto_Hola = pilas.actores.Texto('Hola, ')
                texto_Hola.y = 50
                texto_nombre = pilas.actores.Texto(nombre)
		self.fondo = self.pilas.fondos.Fondo("fondo.jpg")

[/quote]

Fijate que en texto_Hola hay una tabulación de más. Seguramente por eso te está dando error. :wink:

Primero mejore el menu y los escenarios, los cuales ya no me salieron ningún tipo de error, pero nuevamente al colocar PantallaIngreso (para ingresar datos), me sale el siguiente error:

»
× # TypeError: iniciar() takes exactly 2 arguments (1 given)
× # La clase PantallaMenu arrojó un error al ser inicializada, asegurá que el método PantallaMenu.iniciar (que solo admite los argumetos: ArgSpec(args=[‘self’, ‘nombre’], varargs=None, keywords=None, defaults=None)) en realidad fue invocada con los argumentos: () {}
× #
× # Traza del error (las llamadas mas recientes al final):
× # Archivo “C:\PILAS-~1\pilasengine\interprete\editor.py”,linea 646, en ejecutar
× # exec(contenido, self.interpreterLocals)
× # Archivo actual,linea 367, en
× # Archivo “C:\PILAS-~1\pilasengine\escenas_init_.py”,linea 130, en metodo_crear_escena
× # raise TypeError(str(error) + mensaje_extendido)
× # TypeError: iniciar() takes exactly 2 arguments (1 given)
× # La clase PantallaMenu arrojó un error al ser inicializada, asegurá que el método PantallaMenu.iniciar (que solo admite los argumetos: ArgSpec(args=[‘self’, ‘nombre’], varargs=None, keywords=None, defaults=None)) en realidad fue invocada con los argumentos: () {}
× #

»

Revisé los espacios, hice tabulaciones y todo está bien, el error me sale en la PantallaMenu donde se recoge el nombre de la Pantalla anterior (self, nombre)

Eso es por que se hace una llamada a la pantalla menú en la que falta el parámetro ‘nombre’, por lo cual te está indicando que falta un parámetro por pasar. Quizás en tu caso, en la que se llama a la pantalla del menú desde diferentes partes del juego, te convendria más pasar el ‘nombre’ como una variable de tipo GLOBAL De esta manera la escena menú te saludará siempre con el nombre introducido tanto si justo empiezas el juego como si vienes de leer las instrucciones, o de cualquier otra escena. Te paso el ejemplo que hice en su dia:

Espero que esto te ayude ! :wink:

###coding utf8###

import pilasengine
pilas = pilasengine.iniciar()

nombre = '' ###CAMBIADO###

class PantallaIngreso(pilasengine.escenas.Escena):
    def iniciar(self):
        self.valor1 = pilas.interfaz.IngresoDeTexto()
        self.valor1.texto =u'Nombre?'
        botonInicio = pilas.interfaz.Boton('Iniciar Juego')
        botonInicio.conectar(self.al_pulsar_el_boton)
    def obtener_valor(self, actor_texto):
        return str(actor_texto.texto)
    def al_pulsar_el_boton(self):
        global nombre ###CAMBIADO###
        nombre = self.obtener_valor(self.valor1)
        
        pilas.escenas.PantallaMenu()
                        
class PantallaMenu(pilasengine.escenas.Escena):
    def iniciar(self): ###CAMBIADO###
		global nombre
		texto_Hola = pilas.actores.Texto('Hola, ')
		texto_Hola.y = 150
		texto_nombre = pilas.actores.Texto(nombre)
		texto_nombre.y = 120

Y al final del código debes cambiar la escena inicial, ya que tienes puesto que pilas inicie en la pantalla del menú y no en la de ingreso de nombre…

pilas.escenas.vincular(PantallaIngreso)      
pilas.escenas.vincular(PantallaMenu)
pilas.escenas.vincular(PantallaAyuda)
pilas.escenas.vincular(PantallaJuego)
pilas.escenas.vincular(PantallaBienvenida)

pilas.escenas.PantallaIngreso() ####CAMBIADO####

pilas.ejecutar()

Hecho esto el juego se iniciará, pero lamento decirte que no para de darme errores en las COLISIONES, tanto en sumas y restas como en multiplicaciones.

Revisa esas colisiones por si te faltara algún “self” que poner, ya que ahora mismo no reconoce ni “caja” ni “planeta”

Suerte. :wink:

Con esa orden estás eliminando todo menos el actor mono. Si eliminas el actor puntaje y el de errores se pierden los valores.

Antes de eliminar esos actores quizás deberías guardar su valor en una variable y usarla para mostrar la puntuación.

Un saludo :wink: