Juego de Preguntas y Respuestas v.1.4.11

Buenas! Estoy tratando de realizar el siguiente juego:

Ese código lo había realizado en el pilas 0.83, lo modifiqué a la versión actual 1.4.11 viendo el manual y recurriendo a la web.
Por el momento llevo este código:

import pilasengine
pilas = pilasengine.iniciar()
pilas.fondos.Tarde()
lista = [["1 El albinismo se presenta por la carencia de:", "a Calcio", "b Pigmentacion", "c Vitamina A"],["2 Al periodico que se publica en horas de la tarde, se denomina", "a Matutino", "b Clandestino", "c Vespertino"],["3 Es el paso del agua del estado liquido al estado gaseoso", "a Sublimacion", "b Evaporacion", "c Infiltracion"], ["4 Que elemento quimico es representado por el simbolo P?", "a Boro", "b Fosforo", "c Rubidio"],["5 Segun el refran, el que se acuesta a dormir, es porque cria:", "a Suenio", "b Flojera", "c Fama"], ["6 Cual es el idioma oficial de Israel?", "a Japones", "b Griego", "c Hebreo"], ["7 El timbal es un instrumento de:", "a Percusion", "b Viento metal", "c Cuerda"],["8 A que tipo de animales se refiere la palabra aviario?", "a Moluscos", "b Peces", "c Aves"],["9 En la mitologia griega, Eros es considerado el dios del:", "a Amor", "b Miedo", "c Odio"], ["10 Cual de estos animales es un rumiante?", "a La ardilla", "b La vaca", "c El loro"]]
respcorr = ["b", "c", "b", "b", "c", "c", "a", "c", "a", "b"]

class EscenaMenu(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"Ayuda", self.Ayuda),
				(u"Salir", self.Salir_de_Pilas)
			])
		
		Nombre_de_juego = pilas.actores.Texto(u"Comelón el Respondon")
		Nombre_de_juego.color = pilas.colores.rojo
		Nombre_de_juego.y = 170
	
	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.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_juego = pilas.fondos.Tarde()
		puntaje = pilas.actores.Puntaje(color="blanco")
		puntaje.x = -300
		puntaje.y = 220
		self.mono = pilas.actores.Mono()
		self.mono.aprender(pilas.habilidades.Arrastrable)
		self.mono.aprender(pilas.habilidades.MoverseConElTeclado)
		self.mono.decir("Bienvenido/a")
		self.mono.x=[0,200],1
		self.b1=pilas.actores.Banana()
		self.b1.x=-300
		self.b1.y=100
		self.b2=pilas.actores.Banana()
		self.b2.x=-300
		self.b2.y=0
		self.b3=pilas.actores.Banana()
		self.b3.x=-300
		self.b3.y=-100
		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 el_mono_come(bananas,mono):
		banana.eliminar()
		mono.sonrie()
		
	def Volver(self):	
		pilas.escenas.EscenaMenu()
		
	def actualizar(self):
		pass
	
pilas.escenas.vincular(EscenaAyuda)
pilas.escenas.vincular(EscenaMenu)
pilas.escenas.vincular(EscenaJuego)
pilas.escenas.EscenaMenu()

pilas.ejecutar()

Antes que nada, ¿cómo logro hacer la colisión entre las bananas y el mono? Porque están dentro de class.
¿Cómo logro que aparezcan las preguntas que yo tengo en una lista, con sus tres respuestas posibles?

Muchas gracias.

Buenas, @MaxiAlbarenque

Me alegra ver que has adaptado tu código a la nueva versión de Pilas.

Te expongo tu código un poco corregido, y con las sugerencias para que tú mismo encuentres las respuestas y en el proceso aprendas a programar (que es la filosofia en que se basa este foro y el mismo Pilas-Engine) :wink:

Un saludo.

###coding utf8###

import pilasengine
pilas = pilasengine.iniciar()
###pilas.fondos.Tarde() NO PROCEDE
# lista cambiada a EscenaJuego

class EscenaMenu(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"Ayuda", self.Ayuda),
				(u"Salir", self.Salir_de_Pilas)
			])
		
		Nombre_de_juego = pilas.actores.Texto(u"Comelón el Respondon")
		Nombre_de_juego.color = pilas.colores.rojo
		Nombre_de_juego.y = 170
	
	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.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):
		# Lista cambiada de lugar. No le veo la logica a hacer lista de respuestas correctas...
		#en cambio yo pondria todas las respuestas correctas justo despues de la pregunta.
		#De esta manera ya sabemos que la pregunta ocupa el 0 de la lista, el 1 es resp. correcta
		#y las posiciones 2 y 3 de cada lista son respuestas incorrectas.
		
		#hay que cambiar el orden de las respuestas
		#y poner la correcta justo despues de la pregunta
		lista = [["1 El albinismo se presenta por la carencia de:", "a Calcio", "b Pigmentacion", "c Vitamina A"],["2 Al periodico que se publica en horas de la tarde, se denomina", "a Matutino", "b Clandestino", "c Vespertino"],["3 Es el paso del agua del estado liquido al estado gaseoso", "a Sublimacion", "b Evaporacion", "c Infiltracion"], ["4 Que elemento quimico es representado por el simbolo P?", "a Boro", "b Fosforo", "c Rubidio"],["5 Segun el refran, el que se acuesta a dormir, es porque cria:", "a Suenio", "b Flojera", "c Fama"], ["6 Cual es el idioma oficial de Israel?", "a Japones", "b Griego", "c Hebreo"], ["7 El timbal es un instrumento de:", "a Percusion", "b Viento metal", "c Cuerda"],["8 A que tipo de animales se refiere la palabra aviario?", "a Moluscos", "b Peces", "c Aves"],["9 En la mitologia griega, Eros es considerado el dios del:", "a Amor", "b Miedo", "c Odio"], ["10 Cual de estos animales es un rumiante?", "a La ardilla", "b La vaca", "c El loro"]]
		#respcorr = ["b", "c", "b", "b", "c", "c", "a", "c", "a", "b"]

		self.fondo_juego = pilas.fondos.Tarde()
		
		self.puntaje = pilas.actores.Puntaje(texto=10, color="blanco") #self, EDITADO 1
		self.puntaje.x = -300 #self
		self.puntaje.y = 220 #self
		#self.puntaje.valor = 10 #EDITADO 1
		
		self.mono = pilas.actores.Mono()
		self.mono.escala = 0.8 #añadido, el mono era muy grande
		self.mono.aprender('arrastrable') #modificado
		self.mono.aprender('MoverseConElTeclado') #modificado
		self.mono.decir("Bienvenido/a")
		self.mono.x=[0,200],1
		
		self.b1=pilas.actores.Banana()
		self.b1.x=-300
		self.b1.y=100
		self.b2=pilas.actores.Banana()
		self.b2.x=-300
		self.b2.y=0
		self.b3=pilas.actores.Banana()
		self.b3.x=-300
		self.b3.y=-100
		
		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)
		
		#añadimos las colisiones
		pilas.colisiones.agregar('banana', 'mono', self.el_mono_come)#añadido
		
		#añadimos tarea
		pilas.tareas.agregar(3, self.Preguntando)
		
	def Preguntando(self):
		pass
		#AQUI EL CODIGO DE LAS PREGUNTAS
		
		# Hay que hacer un metodo para mostrar la pregunta en pantalla...
		#deberia ser aleatorio pilas.azar() para que la pregunta sea aleatoria,
		#aunque tambien se podrian hacer correlativas y siempre
		#saldrian en el mismo orden :(
		
		# Otro metodo pilas.azar() para el orden en que se mostraran las preguntas
		#de manera aleatoria, para que no sea siempre la de arriba la correcta
			
		# Hay que ligar cada banana con su respuesta, para que cuando haya colision
		#poder detectar si ha sido correcta o incorrecta
		 
		
	def el_mono_come(self, bananas, mono):
		bananas.eliminar()#rectificado
		mono.sonreir()#rectificado
		
		# OJO HAY QUE IMPLEMENTAR UN METODO EN EL QUE SI
		#LA RESPUESTA ES CORRECTA SUME PUNTOS Y SI ES
		#INCORRECTA RESTE PUNTOS
		
		#añadido
		if self.puntaje.valor < 19:
			self.puntaje.aumentar()
		else:
			pilas.avisar('FELICIDADES, HAS GANADO!!!')
			
	def Volver(self):	
		pilas.escenas.EscenaMenu()
		
	def actualizar(self):
		pass
	
	
pilas.escenas.vincular(EscenaAyuda)
pilas.escenas.vincular(EscenaMenu)
pilas.escenas.vincular(EscenaJuego)

pilas.escenas.EscenaMenu()

pilas.ejecutar()

Hola @jordinur !, realmente no tengo palabras para agradecerte el tiempo que te tomas para responder. Si, con tu ayuda lo pude adaptar!. Como vos decías, tengo que hacer la pregunta de forma aleatoria utilizando el pilas.azar(), ¿puede ser parecido a el siguiente juego el modo de utilizarlo?.

import pilasengine
pilas = pilasengine.iniciar()


puntaje = pilas.actores.Puntaje(texto=10,color="azul")

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
    pilas.fondos.Tarde()   #fondo para manzanas
    preg1 = pilas.azar(0,10)
    preg2 = pilas.azar(0,10)
    pregunta = pilas.actores.Texto("Cuanto es: " + str(preg1) + " * " + str(preg2),
                y=180,magnitud=25)

    #aca reemplaze las cajas por manzanas (cajas escala=2, manzanas escala=1)
    caja1 = pilas.actores.Manzana(x = -200, y = 70)
    caja1.imagen = "Manzana.png"
    caja1.escala = 1
    caja1.esverdadera = False


    caja2 = pilas.actores.Manzana(x = 0, y = 70)
    caja2.imagen = "Manzana.png"
    caja2.escala = 1
    caja2.esverdadera = False



    caja3 = pilas.actores.Manzana(x = 200, y = 70)
    caja3.imagen = "Manzana.png"
    caja3.escala = 1
    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 verdader
    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
	if puntaje.valor < 20:
		puntaje.aumentar()

			# Reinicia el juego pasados los 2 segundos.
		pilas.tareas.una_vez(2, reiniciar)
			
	else:
		pilas.avisar(u'FELICIDADES, HAS GANADO!!!')

crear_una_nueva_pregunta()

Solo que yo tengo las preguntas y respuestas, y en tal caso yo debería de guardar la respuesta correcta en una variable y utilizar pilas.azar() para que no se encuentre en la misma posición siempre, lo mismo con la pregunta.

No encuentro en el manual, el modo de utilizar azar teniendo una lista. O quizá yo estoy tan abrumado con esto que no se para donde ir.

De todas maneras no se si estoy pensando bien en la resolución, por más de no ser programador neto estoy intentando ponerle el mayor esfuerzo para resolverlo tomando información de todos lados :disappointed_relieved:.

Más que una lista lo que tú tienes es una lista de listas… tambien conocido como GRILLA. Cada lista de tu grilla contiene una pregunta y tres respuestas, y la grilla puede contener tantas listas como preguntas quieras hacer, sin límite.

Para acceder a la primera pregunta de tu grilla, a la que tú llamas “lista” seria

lista[0][0]
Es decir, la posición 0 de la lista 0 de tu grilla (recordemos que en Python se empieza siempre por el 0)

La primera respuesta de la primera pregunta (la que te dije que pusieras la respuesta correcta) seria

lista[0][1]
Es decir, la segunda posición de la primera lista de tu grilla

La segunda y tercera respuestas a la primera pregunta (erróneas) serian respectivamente

lista[0][2]
lista[0][3]

preguntar = pilas.azar(0,(len(lista)))
Esto crea un número al azar entre 0 y el total de preguntas y respuestas que tu hayas creado en tu grilla, y almacena ese número aleatorio en la variable “preguntar”. El motivo es hacer una pregunta al azar, para que no sean siempre las mismas preguntas en el mismo orden, lo que seria muy aburrido.

pregunta_a_mostrar = lista[preguntar][0]
“preguntar” es el numero aleatorio, y el “0” es por que en la posición 0 siempre está la pregunta

respuesta_correcta = lista[preguntar][1]
en la posición 1 siempre estaría la respuesta correcta

respuesta_incorrecta_1 = lista[preguntar][2]
respuesta_incorrecta_2 = lista[preguntar][3]
Obviamente :smile:

Empieza por esto (comprende bien la mecánica de las grillas y si hace falta busca un poco más en google) e intenta construir un método para que la posición en pantalla de las tres respuestas (una correcta y dos falsas) sea aleatoria tambien.

Un saludo :wink:

Exacto @jordinur ! Una lista de listas sería, sin embargo estaba probando lo que mencionas. También en papel estuve pensando en como hacerlo y recurrí a la condición if, que más adelante supongo probaré con el código.
Con lo que me dijiste, intente que salga al menos la primer pregunta que se supone toma la variable, obtenida en azar.

class EscenaJuego(pilasengine.escenas.Escena):
	def iniciar(self):
		# Lista cambiada de lugar. No le veo la logica a hacer lista de respuestas correctas...
		#en cambio yo pondria todas las respuestas correctas justo despues de la pregunta.
		#De esta manera ya sabemos que la pregunta ocupa el 0 de la lista, el 1 es resp. correcta
		#y las posiciones 2 y 3 de cada lista son respuestas incorrectas.
		
		#hay que cambiar el orden de las respuestas
		#y poner la correcta justo despues de la pregunta
		lista = [["1 El albinismo se presenta por la carencia de:", "Pigmentacion", "Calcio", "Vitamina A"],["2 Al periodico que se publica en horas de la tarde, se denomina", "Vespertino", "Clandestino", "Matutino"],["3 Es el paso del agua del estado liquido al estado gaseoso", "Evaporacion", "Sublimacion", "Infiltracion"], ["4 Que elemento quimico es representado por el simbolo P?", "Fosforo", "Boro", "Rubidio"],["5 Segun el refran, el que se acuesta a dormir, es porque cria:", "Fama", "Flojera", "Suenio"], ["6 Cual es el idioma oficial de Israel?", "Hebreo", "Griego", "Japones"], ["7 El timbal es un instrumento de:", "a Percusion", "b Viento metal", "c Cuerda"],["8 A que tipo de animales se refiere la palabra aviario?", "Aves", "Peces", "Moluscos"],["9 En la mitologia griega, Eros es considerado el dios del:", "a Amor", "b Miedo", "c Odio"], ["10 Cual de estos animales es un rumiante?", "La vaca", "La Ardilla", "El loro"]]
		#respcorr = ["b", "c", "b", "b", "c", "c", "a", "c", "a", "b"]

		self.fondo_juego = pilas.fondos.Tarde()
		
		self.puntaje = pilas.actores.Puntaje(color="blanco") #self
		self.puntaje.x = -300 #self
		self.puntaje.y = 220 #self
		self.puntaje.valor = 10 #añadido
		
		self.mono = pilas.actores.Mono()
		self.mono.escala = 0.8 #añadido, el mono era muy grande
		self.mono.aprender('arrastrable') #modificado
		self.mono.aprender('MoverseConElTeclado') #modificado
		self.mono.decir("Bienvenido/a")
		self.mono.x=[0,200],1
		
		self.b1=pilas.actores.Banana()
		self.b1.x=-300
		self.b1.y=100
		self.b2=pilas.actores.Banana()
		self.b2.x=-300
		self.b2.y=0
		self.b3=pilas.actores.Banana()
		self.b3.x=-300
		self.b3.y=-100
		
		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)
		
		
		#añadimos las colisiones
		pilas.colisiones.agregar('banana', 'mono', self.el_mono_come)#añadido
		
		#añadimos tarea
		pilas.tareas.agregar(3, self.Preguntando)
		
	def Preguntando(self):	
		poslista=pilas.azar(0,10)
		encuentrapreg=lista[poslista][0]
		respuesta_correcta = lista[poslista][1]
		respuesta_incorrecta_1 = lista[poslista][2]
		respuesta_incorrecta_2 = lista[poslista][3]
		mostrar_pregunta=pilas.actores.Texto(encuentrapreg)
		
		
		#AQUI EL CODIGO DE LAS PREGUNTAS
		
		# Hay que hacer un metodo para mostrar la pregunta en pantalla...
		#deberia ser aleatorio pilas.azar() para que la pregunta sea aleatoria,
		#aunque tambien se podrian hacer correlativas y siempre
		#saldrian en el mismo orden :(
		
		# Otro metodo pilas.azar() para el orden en que se mostraran las preguntas
		#de manera aleatoria, para que no sea siempre la de arriba la correcta
			
		# Hay que ligar cada banana con su respuesta, para que cuando haya colision
		#poder detectar si ha sido correcta o incorrecta
		
		
	def el_mono_come(self, bananas, mono):
		bananas.eliminar()#rectificado
		mono.sonreir()#rectificado
		
		# OJO HAY QUE IMPLEMENTAR UN METODO EN EL QUE SI
		#LA RESPUESTA ES CORRECTA SUME PUNTOS Y SI ES
		#INCORRECTA RESTE PUNTOS
		
		#añadido
		if self.puntaje.valor < 19:
			self.puntaje.aumentar()
		else:
			pilas.avisar('FELICIDADES, HAS GANADO!!!')
			
	def Volver(self):	
		pilas.escenas.EscenaMenu()
		
	def actualizar(self):
		pass
	def Preguntando(self):	
		poslista=pilas.azar(0,10)
		encuentrapreg=lista[poslista][0]
		respuesta_correcta = lista[poslista][1]
		respuesta_incorrecta_1 = lista[poslista][2]
		respuesta_incorrecta_2 = lista[poslista][3]
		mostrar_pregunta=pilas.actores.Texto(encuentrapreg)

En Preguntando, ¿tengo que pasarle el parámetro lista? porque se supone que con mostrar_pregunta indico que aparezca la pregunta en pantalla que lo hago para ver si al menos la pregunta aparece. Pero cuando corro el juego, a los segundos indica que la lista no esta definida, pero esta definida en iniciar(self).
La pregunta es: ¿cómo le paso el parámetro lista a Preguntando?

Acá el error:

Muchas gracias nuevamente, un saludo!.

En la def iniciar ponle un self. delante de lista

self.lista = [[“1 El albinismo se presenta por la carencia de:”…

y cada vez que hagas referencia a lista usa

self.lista

ya de paso usa el self en cualquier actor o función que uses… para evitar ese problema en un futuro.

def Preguntando(self):
self.poslista = pilas.azar(0,10)
self.encuentrapreg = self.lista[self.poslista][0]
self.respuesta_correcta = self.lista[self.poslista][1]
self.respuesta_incorrecta_1 = self.lista[self.poslista][2]
self.respuesta_incorrecta_2 = self.lista[self.poslista][3]
self.mostrar_pregunta = pilas.actores.Texto(self.encuentrapreg)

@jordinur , voy a hacer eso! por el momento había copiado nuevamente la lista dentro de Preguntando y se había solucionado. Ya mismo cambio lo que me mencionas.

A veces a mi tambien me pasa que debo cerrar la ventana de Pilas, y volver a cargar el fichero py, pareciera que quedara en memoria algo del código antes de ser reformado. Yo te aconsejaria que cada vez que reformes el código en tu editor vuelvas a cargar como de nuevo el juego para probarlo. Esto no me pasaba en Linux, sólo en Windows… :dizzy_face:

Espero tener pronto mi Linux instalado y funcionando, porque lo añoro mucho :cold_sweat: y la verdad es que pilas se me integraba mucho mejor!

Viendo la foto que has puesto, quizás deberías cambiar el tamaño de la fuente, porque parece ser que no te cabe la pregunta en pantalla !!! :smile:

Si es verdad! Lo cierro, y lo vuelvo a abrir para que no me pase eso.

También tengo que cambiar el tamaño como vos decis, pero como todo se ve una vez arrancado el juego recién me doy cuenta.
Sabes que probé modificando lo de la lista, y poniendo self a las funciones y actores, pero ¿cómo es que la lista llega como parámetro?. Porque ahora me dice:

Habiendo solo modificado:

	def Preguntando(self):	
		self.poslista=pilas.azar(0,10)
		self.encuentrapreg=lista[self.poslista][0] #agregue el self a poslista que indica la pos
		self.respuesta_correcta = lista[self.poslista][1] #agregue el self a poslista que indica la pos
		self.respuesta_incorrecta_1 = lista[self.poslista][2]#agregue el self a poslista que indica la pos
		self.respuesta_incorrecta_2 = lista[self.poslista][3]#agregue el self a poslista que indica la pos
		self.mostrar_pregunta=pilas.actores.Texto(self.encuentrapreg) #agregue self a encuentra preg

y self.lista=…

El self.lista que mencionas, ¿dónde iría colocado?.

Muchas gracias @jordinur !

Perdón @jordinur ! Ya lo solucioné, no habá leído todo el código :disappointed_relieved:!

@jordinur ! Te muestro lo que adelanté.
Logré posicionar la pregunta donde ésta aparece al azar, con sus tres posibles respuestas donde la correcta se posiciona al azar.
Pero al momento de enlazar la banana con la respuesta, todas las bananas se colocan en True, y no entiendo el por qué :disappointed_relieved:, es decir que todas las bananas me generan una estrella (extraída de otro ejemplo).

import pilasengine
pilas = pilasengine.iniciar()

class EscenaMenu(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"Ayuda", self.Ayuda),
				(u"Salir", self.Salir_de_Pilas)
			])
		
		Nombre_de_juego = pilas.actores.Texto(u"Comelón el Respondon")
		Nombre_de_juego.color = pilas.colores.rojo
		Nombre_de_juego.y = 170
	
	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.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.lista=[["El albinismo se presenta por la carencia de:", "Pigmentacion", "Calcio", "Vitamina A"],["Al periodico que se publica en horas de la tarde, se denomina", "Vespertino", "Clandestino", "Matutino"],["Es el paso del agua del estado liquido al estado gaseoso", "Evaporacion", "Sublimacion", "Infiltracion"], ["Que elemento quimico es representado por el simbolo P?", "Fosforo", "Boro", "Rubidio"],["Segun el refran, el que se acuesta a dormir, es porque cria:", "Fama", "Flojera", "Suenio"], ["Cual es el idioma oficial de Israel?", "Hebreo", "Griego", "Japones"], ["El timbal es un instrumento de:", "Percusion", "Viento metal", "Cuerda"],["A que tipo de animales se refiere la palabra aviario?", "Aves", "Peces", "Moluscos"],["En la mitologia griega, Eros es considerado el dios del:", "Amor", "Miedo", "Odio"], ["Cual de estos animales es un rumiante?", "La vaca", "La Ardilla", "El loro"]]
		#respcorr = ["b", "c", "b", "b", "c", "c", "a", "c", "a", "b"]

		self.fondo_juego = pilas.fondos.Tarde()
		
		self.puntaje = pilas.actores.Puntaje(color="blanco") #self
		self.puntaje.x = -300 #self
		self.puntaje.y = 220 #self
		self.puntaje.valor = 0 #añadido
		
		self.vidas=pilas.actores.Puntaje(color="rojo")
		self.vidas.valor=3
		self.vidas.x=-220
		self.vidas.y=-220
		
		
		self.mono = pilas.actores.Mono()
		self.mono.escala = 0.8 #añadido, el mono era muy grande
		self.mono.aprender('arrastrable') #modificado
		self.mono.aprender('MoverseConElTeclado') #modificado
		self.mono.decir("Bienvenido/a")
		self.mono.x=[0,200],1
		
		self.b1=pilas.actores.Banana()
		self.b1.x=-300
		self.b1.y=100
		self.b2=pilas.actores.Banana()
		self.b2.x=-300
		self.b2.y=0
		self.b3=pilas.actores.Banana()
		self.b3.x=-300
		self.b3.y=-100
		
		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)
		
		
		#añadimos las colisiones
		pilas.colisiones.agregar('banana', 'mono', self.el_mono_come)#añadido
		
		#añadimos tarea
		pilas.tareas.agregar(3, self.Preguntando)

		
	def Preguntando(self):	
		self.poslista=pilas.azar(0,9)
		self.encuentrapreg=self.lista[self.poslista][0]
		self.mostrar_pregunta=pilas.actores.Texto(self.encuentrapreg)
		self.mostrar_pregunta.y=220
		self.mostrar_pregunta.escala=0.8
		
		self.respuesta_correcta = self.lista[self.poslista][1] #Respuesta Correcta
		self.respuesta_incorrecta_1 = self.lista[self.poslista][2] #Respuesta incorrecta 1
		self.respuesta_incorrecta_2 = self.lista[self.poslista][3] #Respuesta incorrecta 2
		
		self.b1.esverdadera=False
		self.b2.esverdadera=False
		self.b3.esverdadera=False
		
		self.rta_1 = pilas.actores.Texto("")
		self.rta_1.x=-250
		self.rta_1.y=100
		self.rta_2 = pilas.actores.Texto("")
		self.rta_2.x=-250
		self.rta_2.y=0
		self.rta_3 = pilas.actores.Texto("")
		self.rta_3.x=-250
		self.rta_3.y=-100
		
		self.bananas_posibles = [self.b1,self.b2,self.b3]
		self.textos_posibles = [self.rta_1,self.rta_2,self.rta_3]
		self.indiceok=pilas.azar(0,2)
		self.banana_verdadera=self.bananas_posibles[self.indiceok]
		self.banana_verdadera.esverdadera=True
		self.texto_respuesta_verdadera=self.textos_posibles[self.indiceok]
		
		if self.b1.esverdadera:
			self.rta_1.texto=str(self.respuesta_correcta)
			self.rta_2.texto = str(self.respuesta_incorrecta_1)
			self.rta_3.texto = str(self.respuesta_incorrecta_2)
		elif self.b2.esverdadera:
			self.rta_2.texto=str(self.respuesta_correcta)
			self.rta_1.texto = str(self.respuesta_incorrecta_1)
			self.rta_3.texto = str(self.respuesta_incorrecta_2)
		elif self.b3.esverdadera:
			self.rta_3.texto= str(self.respuesta_correcta)
			self.rta_1.texto = str(self.respuesta_incorrecta_1)
			self.rta_2.texto = str(self.respuesta_incorrecta_2)
		
			
		# Hay que ligar cada banana con su respuesta, para que cuando haya colision
		#poder detectar si ha sido correcta o incorrecta
		
		
	def el_mono_come(self, bananas, mono):
		if self.banana_verdadera.esverdadera==False:
			bananas.eliminar()#rectificado
			mono.gritar()#rectificado
			mono.decir("MAL MAL MAL")
			
		# OJO HAY QUE IMPLEMENTAR UN METODO EN EL QUE SI
		#LA RESPUESTA ES CORRECTA SUME PUNTOS Y SI ES
		#INCORRECTA RESTE PUNTOS
		else:
			mono.decir("Muy bien")
			estrella = pilas.actores.Estrella()
			estrella.x = bananas.x
			estrella.y = bananas.y
			estrella.escala = 0.2
			estrella.escala = [2, 1] * 2
			self.puntaje.aumentar()
		
			
	def Volver(self):	
		pilas.escenas.EscenaMenu()
		
	def actualizar(self):
		pass


pilas.escenas.vincular(EscenaAyuda)
pilas.escenas.vincular(EscenaMenu)
pilas.escenas.vincular(EscenaJuego)

pilas.escenas.EscenaMenu()

pilas.ejecutar()

Por otro lado, ¿cómo invoco a la función para que me genere otra pregunta?.

Muchas gracias, saludos!.

def el_mono_come(self, bananas, mono):
		if not bananas.esverdadera: #bananas es la banana colisionada
			bananas.eliminar()
			mono.gritar()
			mono.decir("MAL MAL MAL")
			self.puntaje.reducir() #penalizamos el error
		
		else:
			bananas.eliminar() #hay que eliminar la banana colisionada
			mono.decir("Muy bien")
			estrella = pilas.actores.Estrella()
			estrella.x = bananas.x
			estrella.y = bananas.y
			estrella.escala = 0.2
			estrella.escala = [2, 1] * 2
			self.puntaje.aumentar()
			
			pilas.tareas.agregar(3, self.Reiniciar) #NUEVA DEF!!!

En cuanto a hacer otra pregunta, hay que programar una def Reiniciar que esté en la escena del juego. En esa def reiniciar se eliminarán todos los actores (menos el fondo, el puntaje y el mono, que deben quedar en pantalla), y se llamará de nuevo a la def Preguntando. Para eso tambien es necesario cambiar de sitio las bananas b1, b2, b3 que ahora están en la def inicio, y ponerlas en la def Preguntando.

Ánimo, que ya casi lo tienes ! :wink:

Genio @jordinur !, me estaba volviendo loco para realizar esto.
Te dejo el código para que lo veas! Estuve a nada de preguntarte acerca del def reiniciar, pero lo pude amoldar.

Por otro lado, le cambié lo de restar puntos por aumentar un error, a lo cual lo que quiero lograr es que al tener 3 errores termine el juego. En el mismo sentido, cuando el puntaje llegue a 10 termine ¿debo de crear otra def Fin_del_juego()? donde si llega a 10 gana, sino si tiene 3 errores pierde, ¿estoy pensando cualquier cosa?.

Ah!, también cambié el fondo de la opción ayuda donde burdamente indiqué que es cada cosa por medio de flechas. El fondo no se si lograrás apreciarlo porque lo modifiqué, pero para que a mi me funcione ¿debo tener la imagen en la misma carpeta de mi juego verdad?

import pilasengine
pilas = pilasengine.iniciar()

class EscenaMenu(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"Ayuda", self.Ayuda),
				(u"Salir", self.Salir_de_Pilas)
			])
		
		Nombre_de_juego = pilas.actores.Texto(u"Comelón el Respondon")
		Nombre_de_juego.color = pilas.colores.rojo
		Nombre_de_juego.y = 170
	
	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="fondodeljuego1.png"
		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.lista=[["El albinismo se presenta por la carencia de:", "Pigmentacion", "Calcio", "Vitamina A"],["Al periodico que se publica en horas de la tarde, se denomina", "Vespertino", "Clandestino", "Matutino"],["Es el paso del agua del estado liquido al estado gaseoso", "Evaporacion", "Sublimacion", "Infiltracion"], ["Que elemento quimico es representado por el simbolo P?", "Fosforo", "Boro", "Rubidio"],["Segun el refran, el que se acuesta a dormir, es porque cria:", "Fama", "Flojera", "Suenio"], ["Cual es el idioma oficial de Israel?", "Hebreo", "Griego", "Japones"], ["El timbal es un instrumento de:", "Percusion", "Viento metal", "Cuerda"],["A que tipo de animales se refiere la palabra aviario?", "Aves", "Peces", "Moluscos"],["En la mitologia griega, Eros es considerado el dios del:", "Amor", "Miedo", "Odio"], ["Cual de estos animales es un rumiante?", "La vaca", "La Ardilla", "El loro"]]
		#respcorr = ["b", "c", "b", "b", "c", "c", "a", "c", "a", "b"]

		self.fondo_juego = pilas.fondos.Tarde()
		
		self.puntaje = pilas.actores.Puntaje(color="blanco") #self
		self.puntaje.x = -300 #self
		self.puntaje.y = 220 #self
		self.puntaje.valor = 0 #añadido
		
		self.error=pilas.actores.Puntaje(color="rojo")
		self.error.valor=0
		self.error.x=-300
		self.error.y=-220
		
		self.mono = pilas.actores.Mono()
		self.mono.escala = 0.8 #añadido, el mono era muy grande
		self.mono.aprender('arrastrable') #modificado
		self.mono.aprender('MoverseConElTeclado') #modificado
		self.mono.decir("Bienvenido/a")
		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)
		
		
		#añadimos las colisiones
		pilas.colisiones.agregar('banana', 'mono', self.el_mono_come)#añadido
		
		#añadimos tarea
		pilas.tareas.agregar(3, self.Preguntando)
		
	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.fondo_juego, self.mono,self.error]:
				actor.eliminar()

    # Genera una pregunta nueva
		self.Preguntando()
		
	def Preguntando(self):	
		self.b1=pilas.actores.Banana()
		self.b1.x=-300
		self.b1.y=100
		self.b1.esverdadera=False
		self.b2=pilas.actores.Banana()
		self.b2.x=-300
		self.b2.y=0
		self.b2.esverdadera=False
		self.b3=pilas.actores.Banana()
		self.b3.x=-300
		self.b3.y=-100
		self.b3.esverdadera=False
		
		self.poslista=pilas.azar(0,9)
		self.encuentrapreg=self.lista[self.poslista][0]
		self.mostrar_pregunta=pilas.actores.Texto(self.encuentrapreg)
		self.mostrar_pregunta.y=220
		self.mostrar_pregunta.escala=0.8
		
		self.respuesta_correcta = self.lista[self.poslista][1] #Respuesta Correcta
		self.respuesta_incorrecta_1 = self.lista[self.poslista][2] #Respuesta incorrecta 1
		self.respuesta_incorrecta_2 = self.lista[self.poslista][3] #Respuesta incorrecta 2
		
		self.rta_1 = pilas.actores.Texto("")
		self.rta_1.x=-250
		self.rta_1.y=100
		self.rta_2 = pilas.actores.Texto("")
		self.rta_2.x=-250
		self.rta_2.y=0
		self.rta_3 = pilas.actores.Texto("")
		self.rta_3.x=-250
		self.rta_3.y=-100
		
		#Banana verdadera
		self.bananas_posibles = [self.b1,self.b2,self.b3]
		self.textos_posibles = [self.rta_1,self.rta_2,self.rta_3]
		self.indiceok=pilas.azar(0,2)
		self.banana_verdadera=self.bananas_posibles[self.indiceok]
		self.banana_verdadera.esverdadera=True
		self.texto_respuesta_verdadera=self.textos_posibles[self.indiceok]
		self.texto_respuesta_verdadera.texto=str(self.respuesta_correcta)
		
		if self.b1.esverdadera:
			self.rta_1.texto=str(self.respuesta_correcta)
			self.rta_2.texto = str(self.respuesta_incorrecta_1)
			self.rta_3.texto = str(self.respuesta_incorrecta_2)
		elif self.b2.esverdadera:
			self.rta_2.texto=str(self.respuesta_correcta)
			self.rta_1.texto = str(self.respuesta_incorrecta_1)
			self.rta_3.texto = str(self.respuesta_incorrecta_2)
		elif self.b3.esverdadera:
			self.rta_3.texto= str(self.respuesta_correcta)
			self.rta_1.texto = str(self.respuesta_incorrecta_1)
			self.rta_2.texto = str(self.respuesta_incorrecta_2)
				
		# Hay que ligar cada banana con su respuesta, para que cuando haya colision
		#poder detectar si ha sido correcta o incorrecta

	def el_mono_come(self, bananas, mono):
		if not bananas.esverdadera: #bananas es la banana colisionada
			bananas.eliminar()
			mono.gritar()
			mono.decir("MAL MAL MAL")
			self.error.aumentar() #aumenta 1 error. En total puede ser hasta 3 errores.
			pilas.tareas.agregar(3, self.Reiniciar)
		else:
			bananas.eliminar() #hay que eliminar la banana colisionada
			mono.decir("Muy bien")
			estrella = pilas.actores.Estrella()
			estrella.x = bananas.x
			estrella.y = bananas.y
			estrella.escala = 0.2
			estrella.escala = [2, 1] * 2
			self.puntaje.aumentar()
			pilas.tareas.agregar(3, self.Reiniciar)
			

			
	def Volver(self):	
		pilas.escenas.EscenaMenu()
		
	def actualizar(self):
		pass


pilas.escenas.vincular(EscenaAyuda)
pilas.escenas.vincular(EscenaMenu)
pilas.escenas.vincular(EscenaJuego)

pilas.escenas.EscenaMenu()

pilas.ejecutar()


Muchas gracias, saludos!.

Buenas, @MaxiAlbarenque !

Vamos por partes, porque preguntas varias cosas y si no llevamos un orden nos vamos a liar :slight_smile:

El fondo:

Puedes poner el fondo que tu quieras, tan sólo debes adjuntar el fichero .PNG o JPG, como tu dices, en la misma carpeta que el fichero .py del juego.

Escenas:

Tal como lo planteas yo crearia dos escenas nuevas: una para cuando gana el juego, y otra para cuando pierda, las dos deberian tener un método (un botón o una tecla) para volver al menú inicial.

Ganar y perder:

Tendrás que entrar ese código, yo lo haría en la misma def el_mono_come.
Tendrás que poner unas condiciones IF…ELSE para que si el contador de vidas es == 2 y vuelve a fallar le lleve a la escena de partida perdida.
Igual otra IF…ELSE para que si el puntaje == 9 y vuelve a ganar le lleve a la escena de victoria.

def reiniciar: EDITADO: DISCULPA HE VISTO QUE SI ESTÁ INCLUIDO EL ACTOR “ERROR” :blush:

Observo que te falta incluir el contador de vidas en esa def… tienes que incluirlo en los actores a conservar en pantalla para que no se borre cuando reinicies a cada nueva pregunta.

Y bueno, creo que eso es todo… Si consigues estas cuatro cosas te va a quedar un juego de 10, y te agradeceria mucho que cuando ya lo hayas presentado para la evaluación escolar lo expongas para futuros ejemplos.

Un abrazo :wink:

1 Like

Sin dudas lo voy a subir para que quede acá @jordinur ya que todo lo que logré fue gracias al foro y al manual.

Las dos escenas, ¿las agrego con class EscenaGana y class EscenaPierde por ejemplo?. Y ahí solo defino el fondo y un botón con su respectivo puntaje en ambas.

Por el momento intentaré lograr esto (al menos que pilas avise si gana o pierde):

Muchas gracias por los consejos, saludos!.
Un abrazo :smiley:!

@jordinur , quería comentarte que ya logré realizar las cosas antes mencionadas, aunque para las dos escenas (perdiste/ganaste) hice dos def en las cuales en los if/else que implementé los direccionaba a ganaste si no erraba 3 veces y llegaba a 10 respuestas correctas, y a perdiste si erraba 3 veces. En estos días estaré ajustando varias cosas del juego y pronto lo estaré subiendo para que puedas probarlo.

Por otro lado, ¿no necesito invocar nada más verdad?.

No hay palabras para agradecer el tiempo que te tomaste en responder mis consultas.

Así que sin mas que decir, mas que si se me genera alguna duda te lo haré saber.

Muchas gracias, saludos!

1 Like