Consulta sobre Juego Matemático .(Combinar operaciones de suma y resta ).)

consulta
1

Hola!! Para la universidad me pidieron realizar como trabajo final un juego didáctico , basándome en el aporte del foro pude llegar a lo que tenia en mente . Realice un juego matemático en donde se tienen que contestar correctamente los cálculos que solo son sumas simples ,mi consulta es como podría hacer para que aparezcan combinadas sumas y restas en el juego ,ademas tengo problemas con el puntaje que desaparece , lo que quiero lograr es que pasado 10 juegos avise que ha ganado el jugador.
Gracias.

import pilasengine
pilas = pilasengine.iniciar()
 #defino puntaje
puntaje = pilas.actores.Puntaje(color = 'amarillo')
puntaje.x = -300
puntaje.y = 220
mi_mensaje = pilas.actores.Texto("Presione Esc para volver al menu", y=-210) 
mi_mensaje.color= pilas.colores.Color(205,92,90)     
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_pregunta()
class PantallaBienvenida(pilasengine.escenas.Escena):
    
    def iniciar(self):
       
        self.fondo= self.pilas.fondos.Espacio()
        #Defino Puntaje
        puntaje= pilas.actores.Puntaje(color='amarillo')
        puntaje.x = -300
        puntaje.y = 220
        crear_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):
        pilas.fondos.Noche()
        pilas.actores.Menu(
        [
            ('iniciar Juego' , iniciar_juego),
            ('salir' , salir_del_juego)
        ])
        
def iniciar_juego ():
    print('Iniciar el Juego') 
    pilas.escenas.PantallaBienvenida() 

    
def crear_pregunta():

    #Defino preguntas al azar
    preg1 = pilas.azar(0,50)
    preg2 = pilas.azar(0,50)
    pregunta = pilas.actores.Texto("Cuanto es: " + str(preg1) + " + " + str(preg2),
                y=180,magnitud=25)

    #DEFINO LOS PLANETAS
    planeta1 = pilas.actores.Planeta(x = -200, y = 70)
    planeta1.imagen = "planeta_naranja.png"
    planeta1.escala = 1.5
    planeta1.esverdadera = False


    planeta2 = pilas.actores.Planeta(x = 0, y = 70)
    planeta2.imagen = "planeta_marron.png"
    planeta2.escala = 1.5
    planeta2.esverdadera = False



    planeta3 = pilas.actores.Planeta(x = 200, y = 70)
    planeta3.imagen = "planeta_rojo.png"
    planeta3.escala = 1.5
    planeta3.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)

        #Planetas posibles
    planetas_posibles = [planeta1,planeta2,planeta3]
    textos_posibles = [rta_1,rta_2,rta_3]
    indiceok = pilas.azar(0,2)
    respuesta_verdadera = planetas_posibles[indiceok]
    respuesta_verdadera.esverdadera = True
    texto_de_respuestaok = textos_posibles[indiceok]
    texto_de_respuestaok.texto = str(preg1+preg2)
       #Planetas falsos

    if planeta1.esverdadera:
        rta_2.texto = str(pilas.azar(0,100))
        rta_3.texto = str(pilas.azar(0,100))
    elif planeta2.esverdadera:
            rta_1.texto = str(pilas.azar(0,100))
            rta_3.texto = str(pilas.azar(0,100))
    elif planeta3.esverdadera:
            rta_1.texto = str(pilas.azar(0,100))
            rta_2.texto = str(pilas.azar(0,100))
 
    #CURSOR DISPARO

    cursor_disparo = pilas.actores.CursorDisparo(y=-150)
    cursor_disparo.aprender(pilas.habilidades.Arrastrable)


    #COLISIONES
    planetas = [planeta1,planeta2,planeta3]
    pilas.colisiones.agregar(cursor_disparo,planetas,respuesta)

def respuesta(cursor_disparo, planeta):
    if planeta.esverdadera:
        cursor_disparo.decir("MUY BIEN!!!")

        # Genera una estrella para mostrar que contesto
        # bien
        estrella = pilas.actores.Estrella()
        estrella.x = planeta.x
        estrella.y = planeta.y
        estrella.escala = 0.2
        estrella.escala = [2, 1] * 2
        
        #Aumenta el puntaje
        if puntaje.valor < 10:
            puntaje.aumentar()
        # Reinicia el juego pasados los 2 segundos.
            pilas.tareas.una_vez(2, reiniciar)
        else:
            pilas.avisar("Haz Ganado!!!")
            
        # Reinicia el juego pasados los 2 segundos.
        pilas.tareas.una_vez(2, reiniciar)
    else:
        cursor_disparo.decir("VUELVE A INTENTARLO!")
        pilas.camara.vibrar()
        planeta.eliminar()

def salir_del_juego():
    print('Salir del Juego')
    pilas.terminar()
pilas.escenas.vincular(PantallaMenu)
pilas.escenas.vincular(PantallaBienvenida)

pilas.escenas.PantallaMenu()
pilas.ejecutar()
2

Buenas, @Julieta_Chavez !

Veo que te has tomado el esfuerzo de adaptar este ejemplo a un juego con escenas… :cold_sweat:

Tenemos varios problemas aqui a considerar:

Lo primero, es que hay en tu código muchos problemas de indexación. Esto pasa al mezclar espacios y tabulaciones (seguramente por estar “copia-pega código”, o por usar dos editores diferentes), lo que hace que Python se vuelva un tanto inestable y no sea capaz de reconocer diversas lineas de código. Llevo un buen rato intentando hacer unas pequeñas modificaciones a tu juego, pero no hacen más que saltarme errores, lo que me dificulta mucho el trabajo. Te agradecería mucho si pudieras tomarte la molestia de corregir ese tedioso asunto, eliminando todos los espacios al principio y al final de cada línea y usando sólo los saltos de línea y las tabulaciones. Depende qué editor uses, es posible que seleccionando todo el código tengas opción de cambiar automáticamente todos los espacios por tabulaciones y eliminar fácilmente los espacios al final de las lineas.

Lo segundo, que al incluir escenas deberias poner todas las funciones referidas al desarrollo del juego DENTRO de la escena PantallaBienvenida. Eso incluye el actor puntaje y todos los demás actores, pero tambien todas las “def” para que el juego se lleve a cabo (crear_pregunta, respuesta, etc…)

Las def salir_del_juego y iniciar_juego deberian estar DENTRO de la escena del menú ya que allí es donde se las llama.

Al ponerlo todo en escenas, será necesario que todo lleve el “self” correctamente: actores, procesos, funciones, defs… TODO!!!

EDITADO: SI QUE ES NECESARIO UNA DEF REINICIAR, EN LA ESCENA BIENVENIDA.
Al trabajar en escenas ya no seria necesaria la def reiniciar… cada vez que entres a la escena todo se reinicia automáticamente! Por tanto la def reiniciar se puede eliminar tranquilamente

Ya sé que suena duro pero no desesperes… Si tan sólo fueras capaz de corregir el tema de la indexación y poner bien los self, acabar de pulir y afinar tu código sería realmente fácil. ANIMOS !!! :smile:

Espero prontas noticias tuyas con el código corregido !

Un abrazo :wink:

3

Buenas, @Julieta_Chavez

Te dejo aquí una versión de tu juego, que ya tiene implementada la resta. Para conseguirlo sólo han hecho falta 2 líneas más de código. :wink:

He tenido que configurar mi editor (Geany) para poder trabajar con espacios y tabulaciones al tiempo, para poder editar tu código sin sufrir los errores de identación. Si bien el código es totalmente correcto ( y en mis pruebas es totalmente funcional), el hecho de “copiar y pegar” puede que dé diferentes errores de identación.

Te agradecería que estudies esta versión a fondo, más que nada para que te quede claro el orden y la jerarquía de las class y las defs, a buen seguro que podrás adaptarlo a tus necesidades y hacértelo tuyo y a tu estilo…

Y por favor si hay algo que no entiendes o no te parece bien no dudes en preguntar o comentar.

Un abrazo :slight_smile:

###coding utf8###

import pilasengine
pilas = pilasengine.iniciar()

class PantallaMenu(pilasengine.escenas.Escena):
    def iniciar(self):
	self.fondo_menu = pilas.fondos.Volley()

	self.Mi_Menu = pilas.actores.Menu(
	    [
		(u"Jugar", self.Ir_al_juego),
		(u"Salir", self.Salir_de_Pilas)
	    ])

	Nombre_de_juego = pilas.actores.Texto(u"Sumas y restas")
	Nombre_de_juego.color = pilas.colores.rojo
	Nombre_de_juego.y = 170

	#CURSOR DISPARO
	self.cursor_disparo = pilas.actores.CursorDisparo(y=-150)
	self.cursor_disparo.aprender('arrastrable')
    
    def actualizar(self):
	    pass

    def Salir_de_Pilas(self):
	pilas.terminar()

    def Ir_al_juego(self):
	pilas.escenas.PantallaBienvenida()

class PantallaBienvenida(pilasengine.escenas.Escena):
    
    def iniciar(self):
	self.fondo= self.pilas.fondos.Espacio()
	#Defino Puntaje
	self.texto_puntos =pilas.actores.Texto('Puntos:')
	self.texto_puntos.color= 'amarillo'
	self.texto_puntos.x = -265
	self.texto_puntos.y = 220
	
	self.puntaje= pilas.actores.Puntaje(color='amarillo')
        self.puntaje.x = -195
	self.puntaje.y = 220
	self.crear_pregunta()
	pilas.eventos.pulsa_tecla_escape.conectar(self.regresar)

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

    def crear_pregunta(self):
	suma_resta = pilas.azar(0,1)
	
	#Defino preguntas al azar
	self.preg1 = pilas.azar(0,50)
	self.preg2 = pilas.azar(0,50)
	
	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 LOS PLANETAS
	self.planeta1 = pilas.actores.Planeta(x = -200, y = 70)
	self.planeta1.imagen = "planeta_naranja.png"
	self.planeta1.escala = 1.5
	self.planeta1.esverdadera = False

	self.planeta2 = pilas.actores.Planeta(x = 0, y = 70)
	self.planeta2.imagen = "planeta_marron.png"
	self.planeta2.escala = 1.5
	self.planeta2.esverdadera = False

	self.planeta3 = pilas.actores.Planeta(x = 200, y = 70)
	self.planeta3.imagen = "planeta_rojo.png"
	self.planeta3.escala = 1.5
	self.planeta3.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)

	#Planetas posibles
	planetas_posibles = [self.planeta1,self.planeta2,self.planeta3]
	textos_posibles = [self.rta_1,self.rta_2,self.rta_3]
	indiceok = pilas.azar(0,2)
	respuesta_verdadera = planetas_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)


	#Planetas falsos
	if self.planeta1.esverdadera:
	    self.rta_2.texto = str(pilas.azar(0,100))
	    self.rta_3.texto = str(pilas.azar(0,100))
	elif self.planeta2.esverdadera:
	    self.rta_1.texto = str(pilas.azar(0,100))
	    self.rta_3.texto = str(pilas.azar(0,100))
	elif self.planeta3.esverdadera:
	    self.rta_1.texto = str(pilas.azar(0,100))
	    self.rta_2.texto = str(pilas.azar(0,100))

	#CURSOR DISPARO
	self.cursor_disparo = pilas.actores.CursorDisparo(y=-150)
	self.cursor_disparo.aprender('arrastrable')


	#COLISIONES
	planetas = [self.planeta1, self.planeta2, self.planeta3]
	pilas.colisiones.agregar(self.cursor_disparo, planetas, self.respuesta)

    def respuesta(self, cursor_disparo, planeta):
	if planeta.esverdadera:
	    cursor_disparo.decir("MUY BIEN!!!")

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

	    #Aumenta el puntaje
	    if self.puntaje.valor < 9:
		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()
	    planeta.eliminar()
	    self.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 regresar_menu(self):
	pilas.escenas.PantallaMenu()


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

pilas.escenas.PantallaMenu()
pilas.ejecutar()
4

@jordinur Te agradezco sinceramente por haberme ayudado y si me surge alguna pregunta no voy a dudar en consultarte . Saludos