Ayuda, tengo un menu con 4 opciones:
Iniciar
tutotial
Puntaje
Salir
Quisiera saber si se puede cambiar el tipo de letra y el color de las opciones de menú
Buenas, @JuanGallardo !
Hasta donde yo sé, se puede cambiar el color del texto de las opciones, pero no individualmente. Puedes consultar la API de Pilas, donde se explica el actor Menu.
Te pongo un ejemplo de como cambiar el color:
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'IR AL JUEGO', self.Ir_al_juego),
(u'SALIR DE PILAS', self.Salir_de_Pilas)
])
self.Mi_Menu.color_normal = pilas.colores.rojo
self.Mi_Menu.color_resaltado = pilas.colores.verde
self.Mi_Menu.fuente = None
##############################################
Nombre_de_mi_juego = pilas.actores.Texto(u'MI GRAN JUEGO')
Nombre_de_mi_juego.color = pilas.colores.rojo
Nombre_de_mi_juego.y = 170
def Ir_al_juego(self):
pass
def Salir_de_Pilas(self):
pass
pilas.escenas.vincular(EscenaMenu)
pilas.escenas.EscenaMenu()
pilas.ejecutar()
Yo iria con cuidado en cambiar la fuente, hay que pensar en las personas que usan sistemas Linux y que quizás no tengan instaladas fuentes de propietarios! Eso daria error al ejecutar el juego en sistemas GNU/Linux, si definieras una fuente de Windows.
Espero que esto te ayude !
Un saludo 
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. 
No dudes en volver a comentar cualquier otra duda que te surja, estaremos atentos a tus progresos!
Un abrazo 
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 
Un abrazo.
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
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 !
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. 
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?
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.
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 !