示例#1
0
class Ahorcado(Base):

	def __init__(self, nombre='',datos =''):
		Base.__init__(self)
		self.nombre = nombre
		archivo = open("data/archivos/usuarios.json",'r')
		dato = json.load(archivo)
		archivo.close()
		self.tema = dato[self.nombre]["tema_ahorcado"]
		self.datos = datos
		self.intentos = 6

	def fondo(self):
		pilas.fondos.Fondo("data/img/fondos/ahorcado.jpg")

	def iniciar(self):
		self.fondo()
		self.crear_letras()
		self.titulo = pilas.actores.Actor("data/img/enunciados/ahorcado.png", y= 250)
		self.titulo.escala = 0.4
		palo_ahorcado = pilas.actores.Actor('data/img/iconos/palo_ahorcado.png',x=280,y=100)
		palo_ahorcado.escala = 2
		self.generar_palabra()
	
	def crear_letras(self):
		self.lista_letras = []
		for x in range(len(letras)):
			self.actor_letra = Letra(letra=letras[x], x=cord_letras[x][0], y=cord_letras[x][1])
			self.actor_letra.escala = 0.74
			self.lista_letras.append(self.actor_letra)
			self.actor_letra.activar()
			self.actor_letra.conectar_presionado(self.presiona_tecla, arg=x)

	def presiona_tecla(self, x):
		self.actor_letra = self.lista_letras[x]
		letra_mayus = self.actor_letra.getLetra()
		self.letra = letra_mayus.lower()
		self.intentar()

	def generar_palabra(self):
		#Timer
		self.time = Temporizador(x=-250,y=300)
		self.time.setDatas(0)
		self.time.iniciar_aum()
		self.guion = []
		self.letras_utilizadas = []
		self.letras_adivinadas = 0
		if(self.tema == 'Animales'):
			self.palabra = random.choice(animales)
		if(self.tema == 'Frutas'):
			self.palabra = random.choice(frutas)
		if(self.tema == 'Meses'):
			self.palabra = random.choice(meses)
		if(self.tema == 'Instrumentos'):
			self.palabra = random.choice(instrumentos)
		if (len(self.palabra) <= 5):
			self.posx = -270
			for x in range(0,len(self.palabra)):
				self.actor_guion = pilas.actores.Actor("data/img/interfaz/guion.png",x=self.posx,y=-280)
				self.guion.append(self.posx)
				self.posx = self.posx + 100
				self.actor_guion.escala = 0.12
		elif(len(self.palabra) <= 9):
			self.posx = -400
			for x in range(0,len(self.palabra)):
				self.actor_guion = pilas.actores.Actor("data/img/interfaz/guion.png",x=self.posx,y=-280)
				self.guion.append(self.posx)
				self.posx = self.posx + 100
				self.actor_guion.escala = 0.12
		else:
			self.posx = -450
			for x in range(0,len(self.palabra)):
				self.actor_guion = pilas.actores.Actor("data/img/interfaz/guion.png",x=self.posx,y=-280)
				self.guion.append(self.posx)
				self.posx = self.posx + 80
				self.actor_guion.escala = 0.09

	def gano(self):
		for y in range(0,len(self.lista_letras)):
			self.actor_letra = self.lista_letras[y]
			self.actor_letra.desactivar()
		self.profesor = pilas.actores.Actor("data/img/iconos/profesor.png",x=500,y=-180)
		self.profesor.escala = 0.095
		self.profesor.x = [440]
		self.profesor.decir('Bien echo, ganaste 1 punto mas de energia!')
		self.ener = True
		pilas.mundo.agregar_tarea(1,self.profesor.eliminar)
		pilas.avisar('Volviendo al tablero..')
		pilas.mundo.agregar_tarea(2,self.volver)	

	def perdio(self):
		self.profesor = pilas.actores.Actor("data/img/iconos/profesor.png",x=500,y=-180)
		self.profesor.escala = 0.095
		self.profesor.x = [440]
		self.profesor.decir('Lo siento, perdiste 1 punto de energia!')
		self.ener = False
		pilas.mundo.agregar_tarea(1,self.profesor.eliminar)
		pilas.avisar('Volviendo al tablero..')
		pilas.mundo.agregar_tarea(2,self.volver)	

	def cuerpo(self):
		if(self.intentos == 5):
			cabeza = pilas.actores.Actor('data/img/iconos/cabeza.png',x=263,y=190)
		if(self.intentos == 4):
			torzo = pilas.actores.Pizarra()
			torzo.linea(263,152,263,20,pilas.colores.negro,grosor=6)
		if(self.intentos == 3):
			brazo_derecho = pilas.actores.Pizarra()
			brazo_derecho.linea(263,130,210,95,pilas.colores.negro,grosor=6)
		if(self.intentos == 2):
			brazo_izquierdo = pilas.actores.Pizarra()
			brazo_izquierdo.linea(263,130,316,95,pilas.colores.negro,grosor=6)
		if(self.intentos == 1):
			pierna_derecha = pilas.actores.Pizarra()
			pierna_derecha.linea(263,20,218,-34,pilas.colores.negro,grosor=6)
		if(self.intentos == 0):
			pierna_izquierda = pilas.actores.Pizarra()
			pierna_izquierda.linea(263,20,308,-34,pilas.colores.negro,grosor=6)
			self.perdio()

	def intentar(self):
		no_se_encuentra = True
		indice = 0
		if(self.intentos == 0):
			self.perdio()
		else:
			if(self.letra in self.letras_utilizadas):
				self.profesor = pilas.actores.Actor("data/img/iconos/profesor.png",x=500,y=-180)
				self.profesor.escala = 0.095
				self.profesor.x = [440]
				self.profesor.decir('Ya utilizaste esa letra!')
				pilas.mundo.agregar_tarea(2,self.profesor.eliminar)
			else:
				for x in self.palabra:
					if(self.letra == x):
						no_se_encuentra = False
						break
				if(no_se_encuentra == True):
					self.profesor = pilas.actores.Actor("data/img/iconos/profesor.png",x=500,y=-180)
					self.profesor.escala = 0.095
					self.profesor.x = [440]
					self.profesor.decir('Ups, esa letra no se encuentra en la palabra!')
					pilas.mundo.agregar_tarea(2,self.profesor.eliminar)
					self.letras_utilizadas.append(self.letra)
					self.intentos = self.intentos-1
					self.cuerpo()
				else:
					for x in self.palabra:
						if (self.letra==x) and (self.letras_adivinadas<len(self.palabra)):
							self.letra_adivinada = pilas.actores.Texto(x,fuente="data/fonts/American Captain.ttf",y=-258)
							self.letra_adivinada.escala = 2
							self.letra_adivinada.color = pilas.colores.negro 
							self.letra_adivinada.x = self.guion[indice]
							self.letras_adivinadas = self.letras_adivinadas + 1
							self.letras_utilizadas.append(x)	
							if (self.letras_adivinadas == len(self.palabra)):
								self.gano()
						indice = indice + 1

	def volver(self):
		self.time.stopTimer()
		self.datos[self.nombre]['tiempo_ahorcado'][0] = self.datos[self.nombre]['tiempo_ahorcado'][0] + self.time.getTime()
		self.datos[self.nombre]['tiempo_ahorcado'][1] = self.datos[self.nombre]['tiempo_ahorcado'][1] + 1
		if(self.ener == False):
			self.datos[self.nombre]['tiempo_ahorcado'][2] = self.datos[self.nombre]['tiempo_ahorcado'][2] + 1	
		f = open("data/archivos/estadisticas.json","w")
		f.write(json.dumps(self.datos))
		f.close()
		e = open("data/archivos/energia.txt",'wb')
		pickle.dump(self.ener,e)
		e.close()
		pilas.recuperar_escena()
示例#2
0
class Adivinanza(Base):

	def __init__(self,nombre='',datos = ''):
		Base.__init__(self)
		self.nombre = nombre
		self.datos = datos

	def iniciar(self):
		self.fondo()
		self.interfaz()
		self.generar()

	def fondo(self):
		pilas.fondos.Fondo("data/img/fondos/adivinanza.jpg")

	def interfaz(self):
		#Timer
		self.time = Temporizador(x=-250,y=300)
		self.time.setDatas(0)
		self.time.iniciar_aum()
		#Titulo
		self.texto_titulo = pilas.actores.Actor("data/img/enunciados/adivinanza.png",y=270)
		self.texto_titulo.escala = 0.5
		#Recuadro
		self.recuadro = pilas.actores.Actor("data/img/interfaz/recuadrito.png",x = -20,y = 50)
		self.recuadro.escala = 0.4
		#Personaje
		self.personaje = pilas.actores.Actor("data/img/iconos/character.png",y=-150)
		self.personaje.escala = 0.26
		self.personaje.decir("Clickea en el animal al que hace referencia la adivinanza") ###dialogo
		#Adivinanza
		numero = random.randrange(0,6)
		self.adivinanza = adivinanzas[numero]
		self.texto = pilas.actores.Texto(self.adivinanza,fuente="data/fonts/American Captain.ttf", y = 50 , ancho = 256 )
		self.texto.color = pilas.colores.negro

	def generar(self):
		self.lista_elemento = []
		coor = [(-300,0),(280,-200),(280,200),(280,0),(-280,-200),(-280,200)]
		for x in range(len(lista)):
			self.elemento = Animal(x=coor[x][0],y=coor[x][1],imagen=lista[x])
			self.elemento.escala = 0.6
			self.lista_elemento.append(self.elemento)
			self.elemento.activar()
			self.elemento.conectar_presionado(self.verificar, arg=x)

	def verificar(self,x):
		self.elemento = self.lista_elemento[x]
		seleccion = self.elemento.getElemento()
		if(lista.index(seleccion)== adivinanzas.index(self.adivinanza)):
			self.personaje.decir("Bien hecho , ganaste un rayo de energia")
			self.ener = True
		else:
			self.personaje.decir("Respuesta incorrecta , perdiste un rayo")
			self.ener = False
		pilas.mundo.agregar_tarea(2,self.volver)

	def volver(self):
		self.time.stopTimer()
		self.datos[self.nombre]['tiempo_adivinanza'][0] = self.datos[self.nombre]['tiempo_adivinanza'][0] + self.time.getTime()
		self.datos[self.nombre]['tiempo_adivinanza'][1] = self.datos[self.nombre]['tiempo_adivinanza'][1] + 1
		if(self.ener == False):
			self.datos[self.nombre]['tiempo_adivinanza'][2] = self.datos[self.nombre]['tiempo_adivinanza'][2] + 1	
		f = open("data/archivos/estadisticas.json","w")
		f.write(json.dumps(self.datos))
		f.close()
		e = open("data/archivos/energia.txt",'wb')
		pickle.dump(self.ener,e)
		e.close()
		pilas.recuperar_escena()
示例#3
0
class Tablero(Base):
    def __init__(self, nombre, musica):
        Base.__init__(self)
        self.nombre = nombre
        self.musica = musica
        self.energia = 3

    def fondo(self):
        pilas.fondos.Fondo('data/img/fondos/tablero_img.png')

    def escena_ayuda(self):
        self.sonido_boton.reproducir()
        pilas.almacenar_escena(Ayuda())

    def act(self):
        self.dado.activar()
        self.boton.activar()
        self.ayuda.activar()

    def des(self):
        self.dado.desactivar()
        self.boton.desactivar()
        self.ayuda.desactivar()

    def regresar(self):
        self.sonido_boton.reproducir()
        self.musicaa.solo_detener()
        musica = open("data/archivos/musica.txt", 'rb')
        self.estado = pickle.load(musica)
        musica.close()
        pilas.mundo.deshabilitar_sonido(False)
        if (self.estado == True):
            self.musica.encender()
        elif (self.estado == False):
            self.musica.apagar()
        pilas.recuperar_escena()

    def volver(self):
        def continuar():
            self.sonido_boton.reproducir()
            self.text1.eliminar()
            self.si.eliminar()
            self.no.eliminar()
            self.cartel.eliminar()
            self.act()
            self.timer.continuar()

        def crear_texto():
            self.text1 = pilas.actores.Texto(
                "Esta seguro que desea salir?",
                fuente="data/fonts/American Captain.ttf",
                y=100)
            self.si = pilas.actores.Boton(y=-35)
            self.si.definir_imagen('data/img/interfaz/si.png')
            self.si.escala = 0.7
            self.no = pilas.actores.Boton(y=-165)
            self.no.definir_imagen('data/img/interfaz/no.png')
            self.no.escala = 0.7
            self.si.conectar_presionado(self.regresar)
            self.no.conectar_presionado(continuar)

        self.sonido_boton.reproducir()
        self.timer.stopTimer()
        self.des()
        self.cartel = pilas.actores.Actor('data/img/iconos/cartel.png')
        self.cartel.escala = [1.8, 1], 0.8
        pilas.mundo.agregar_tarea(1, crear_texto)

    def cargar_sonidos(self):
        self.sonido_boton = pilas.sonidos.cargar("data/audio/boton.ogg")
        self.sonido_dado = pilas.sonidos.cargar("data/audio/dice.ogg")
        self.sonido_teleport = pilas.sonidos.cargar("data/audio/teleport.ogg")
        self.sonido_vida = pilas.sonidos.cargar("data/audio/pierde_vida.ogg")
        self.gana_energia = pilas.sonidos.cargar("data/audio/gana_energia.ogg")
        self.pierde_energia = pilas.sonidos.cargar(
            "data/audio/pierde_energia.ogg")
        self.gana_partida = pilas.sonidos.cargar("data/audio/victoria.ogg")
        self.pierde_partida = pilas.sonidos.cargar("data/audio/derrota.ogg")

    def iniciar(self):
        self.fondo()
        archivo = open('data/archivos/usuarios.json', 'r')
        self.usuarios = json.load(archivo)
        archivo.close()
        archivo1 = open('data/archivos/estadisticas.json', 'r')
        self.datos = json.load(archivo1)
        archivo1.close()
        self.estado = True
        self.cargar_sonidos()
        self.crear_tablero()
        self.iniciar_personaje()
        self.crear_interfaz()
        self.casillero_actual = casillero_mapa
        self.camino_actual = camino_1

    def iniciar_sonido(self):
        musica = open("data/archivos/musica.txt", 'rb')
        est = pickle.load(musica)
        musica.close()
        self.music = pilas.sonidos.cargar(
            "data/audio/Enchanted Festival Loop.ogg")
        if est:
            self.music.reproducir(repetir=True)
        self.musicaa = Sonido(musica=self.music,
                              x=-445,
                              y=-190,
                              estado=est,
                              imagen1="data/img/interfaz/on1.png",
                              imagen2="data/img/interfaz/off1.png")

    def crear_interfaz(self):
        self.iniciar_sonido()
        self.boton = pilas.actores.Boton(x=-450, y=-313)
        self.boton.definir_imagen('data/img/interfaz/atras.png')
        self.boton.escala = 0.09
        self.boton.conectar_presionado(self.volver)
        self.ayuda = pilas.actores.Boton(x=-445, y=-250)
        self.ayuda.definir_imagen('data/img/interfaz/ayuda.png')
        self.ayuda.escala = 0.2
        self.ayuda.conectar_presionado(self.escena_ayuda)

    def crear_tablero(self):
        self.mapa()
        self.castillo()
        self.flechas()
        self.crear_casilleros()
        self.titulo_vidas = pilas.actores.Texto(
            "VIDAS:", fuente="data/fonts/American Captain.ttf", x=355, y=332)
        self.crear_vidas()
        self.titulo_energia = pilas.actores.Texto(
            "ENERGIA:", fuente="data/fonts/American Captain.ttf", x=369, y=260)
        self.crear_energia()
        self.titulo_tiempo = pilas.actores.Texto(
            "TIEMPO:", fuente="data/fonts/American Captain.ttf", x=369, y=220)
        self.crear_timer()
        self.dado = Dado(x=-110, y=134)
        self.dado.conectar_presionado(self.tirar_dado)

    def crear_timer(self):
        self.timer = Temporizador(x=420, y=220)
        self.timer.setDatas(self.usuarios[self.nombre]['tiempo'])
        self.timer.iniciar()
        pilas.mundo.agregar_tarea_siempre(1, self.timer_preguntar)

    def timer_preguntar(self):
        if (self.timer.getTime() == 0):
            self.perdio()

    def _cont_energia(self):
        num = 'x' + str(self.energia)
        self.contador_energia = pilas.actores.Texto(
            num, fuente="data/fonts/American Captain.ttf", x=460, y=260)

    def crear_energia(self):
        #Rayo
        self.rayo = pilas.actores.Actor('data/img/iconos/rayo.png',
                                        x=430,
                                        y=260)
        self.rayo.escala = 0.050
        #Energia
        self._cont_energia()

    def crear_vidas(self):
        #Vida 1
        self.vida1 = pilas.actores.Actor('data/img/iconos/corazon.png')
        self.vida1.escala = 0.050
        self.vida1.x = 350
        self.vida1.y = 300
        #Vida 2
        self.vida2 = pilas.actores.Actor('data/img/iconos/corazon.png')
        self.vida2.escala = 0.050
        self.vida2.x = 390
        self.vida2.y = 300
        #Vida 3
        self.vida3 = pilas.actores.Actor('data/img/iconos/corazon.png')
        self.vida3.escala = 0.050
        self.vida3.x = 430
        self.vida3.y = 300
        self.vidas = 3

    def iniciar_personaje(self):
        self.personaje = pilas.actores.Actor('data/img/iconos/character.png')
        self.personaje.escala = 0.2
        self.personaje.x = casillero_mapa[0]
        self.personaje.y = casillero_mapa[1]
        self.personaje.decir("Hola! Empecemos a jugar!")

    def flechas(self):
        #Flecha 1
        self.flecha1 = pilas.actores.Actor(
            'data/img/interfaz/flecha_arriba.png', x=-338, y=-62)
        self.flecha1.escala = 0.040
        #Flecha 2
        self.flecha2 = pilas.actores.Actor(
            'data/img/interfaz/flecha_arriba.png', x=-182, y=-59)
        self.flecha2.escala = 0.040
        #Flecha 3
        self.flecha3 = pilas.actores.Actor(
            'data/img/interfaz/flecha_arriba.png', x=132, y=-58)
        self.flecha3.escala = 0.040
        #Flecha 4
        self.flecha4 = pilas.actores.Actor(
            'data/img/interfaz/flecha_abajo.png', x=-184, y=-251)
        self.flecha4.escala = 0.050

    def castillo(self):
        self.casti = pilas.actores.Actor('data/img/iconos/castillo.png',
                                         x=-365,
                                         y=315)
        self.casti.escala = 0.11

    def mapa(self):
        self.mapita = pilas.actores.Actor('data/img/iconos/mapa.png',
                                          x=391,
                                          y=-325)
        self.mapita.escala = 0.08

    def crear_casilleros(self):
        self.casi_tele = []
        self.casi = casilleros[:]
        self.imagenes_posiciones = casilleros[:]
        self.imagenes = {
            "data/img/iconos/Casillero.png":
            self.usuarios[self.nombre]['casillero_normal'],
            "data/img/iconos/CasilleroVioleta.png":
            self.usuarios[self.nombre]['casillero_violeta'],
            "data/img/iconos/CasilleroNaranja.png":
            self.usuarios[self.nombre]['casillero_naranja'],
            "data/img/iconos/CasilleroVerde.png":
            self.usuarios[self.nombre]['casillero_verde'],
            "data/img/iconos/ahorcado.png":
            4,
            "data/img/iconos/Casillero_comodin.png":
            4,
            "data/img/iconos/pare.png":
            4,
            "data/img/iconos/perder_vida.png":
            4,
            "data/img/iconos/teletransportacion.png":
            4
        }
        for x in range(0, len(casilleros_bifurcacion)):
            casillero = pilas.actores.Actor("data/img/iconos/bifurcacion.png")
            casillero.escala = 0.055
            casillero.x = casilleros_bifurcacion[x][0]
            casillero.y = casilleros_bifurcacion[x][1]
        for x in self.imagenes.keys():
            for i in range(0, self.imagenes[x]):
                casillero = pilas.actores.Actor(x)
                self.posi = random.randrange(0, len(self.casi))
                casille = self.casi[self.posi]
                self.casi.remove(casille)
                self.imagenes_posiciones[self.imagenes_posiciones.index(
                    casille)] = x
                casillero.x = casille[0]
                casillero.y = casille[1]
                casillero.escala = 0.09
                if (x == "data/img/iconos/teletransportacion.png"):
                    tele = (casillero.x, casillero.y)
                    self.casi_tele.append(tele)
        self.guardar_imagenes()

    def guardar_imagenes(self):
        datos = open("data/archivos/imagenes.json", 'w')
        elementos = {
            "imagenes": self.imagenes_posiciones,
            "casilleros": casilleros
        }
        datos.write(json.dumps(elementos))
        datos.close()

    def actualizar_energia(self):
        archivo_energia = open('data/archivos/energia.txt', 'rb')
        boolean = pickle.load(archivo_energia)
        archivo_energia.close()
        self.contador_energia.eliminar()
        if (boolean == True):
            self.energia = self.energia + 1
            self.gana_energia.reproducir()
        else:
            self.energia = self.energia - 1
            self.pierde_energia.reproducir()
        self._cont_energia()
        if (self.energia == 0):
            self.perder_vida()

    def ver_est(self):
        if self.estado:
            self.musicaa.encender()

    def desactivar_sonido(self):
        musica = open("data/archivos/musica.txt", 'rb')
        self.estado = pickle.load(musica)
        musica.close()
        if self.estado:
            self.musicaa.apagar()
            pilas.mundo.deshabilitar_sonido(False)

    def gano(self):
        self.des()
        self.guardar_tiempo()
        self.gana_partida.reproducir()
        pantalla1 = pilas.actores.Actor('data/img/fondos/trono.jpg')
        titulo1 = pilas.actores.Actor('data/img/enunciados/victoria.png')
        titulo1.escala = 0.5
        self.boton1 = pilas.actores.Boton(x=-420, y=-300)
        self.boton1.definir_imagen('data/img/interfaz/atras.png')
        self.boton1.escala = 0.1
        self.boton1.conectar_presionado(self.regresar)

    def perdio(self):
        self.des()
        self.guardar_tiempo()
        self.pierde_partida.reproducir()
        pantalla = pilas.actores.Actor('data/img/fondos/derrota.jpg')
        titulo_perdio = pilas.actores.Actor("data/img/enunciados/derrota.png")
        titulo_perdio.escala = 0.5
        self.boton2 = pilas.actores.Boton(x=-420, y=-300)
        self.boton2.definir_imagen('data/img/interfaz/atras.png')
        self.boton2.escala = 0.1
        self.boton2.conectar_presionado(self.regresar)

    def perder_vida(self):
        self.sonido_vida.reproducir()
        self.contador_energia.eliminar()
        if (self.vidas == 3):
            self.vida3.eliminar()
            self.vidas -= 1
            self.energia = 3
            self._cont_energia()
        elif (self.vidas == 2):
            self.vida2.eliminar()
            self.vidas -= 1
            self.energia = 3
            self._cont_energia()
        elif (self.vidas == 1):
            self.des()
            self.energia = 0
            self._cont_energia()
            self.vida1.eliminar()
            self.perdio()

    def teletransportacion(self):
        self.sonido_teleport.reproducir()
        self.personaje.escala = [0.4, 0.2], 1.5
        casillero_tele = random.choice(self.casi_tele)
        self.casillero_actual = casillero_tele
        if (self.casillero_actual in camino_1):
            self.camino_actual = camino_1
        elif (self.casillero_actual in camino_2):
            self.camino_actual = camino_2
        elif (self.casillero_actual in camino_3):
            self.camino_actual = camino_3
        elif (self.casillero_actual in camino_4):
            self.camino_actual = camino_4
        elif (self.casillero_actual in camino_5):
            self.camino_actual = camino_5
        elif (self.casillero_actual in camino_6):
            self.camino_actual = camino_6
        elif (self.casillero_actual in camino_7):
            self.camino_actual = camino_7
        elif (self.casillero_actual in camino_8):
            self.camino_actual = camino_8
        self.personaje.x = self.casillero_actual[0]
        self.personaje.y = self.casillero_actual[1]
        self.personaje.escala = [0.3, 0.2], 1.5

    def retroceder(self):
        i = self.camino_actual.index(self.casillero_actual) - 1
        self.casillero_actual = self.camino_actual[i]
        self.personaje.x = [self.casillero_actual[0]]
        self.personaje.y = [self.casillero_actual[1]]
        #Parches para que funcione al caer en una bifurcacion
        if (self.casillero_actual in camino_2) and (self.camino_actual.index(
                self.casillero_actual) < 1):
            self.casillero_actual = (self.casillero_actual[0],
                                     self.casillero_actual[1] + 1)
        if (self.casillero_actual in camino_3) and (self.camino_actual.index(
                self.casillero_actual) < 1):
            self.casillero_actual = (self.casillero_actual[0],
                                     self.casillero_actual[1] - 1)
        if (self.casillero_actual in camino_4) and (self.camino_actual.index(
                self.casillero_actual) < 1):
            self.casillero_actual = (self.casillero_actual[0],
                                     self.casillero_actual[1] + 1)
        if (self.casillero_actual in camino_5) and (self.camino_actual.index(
                self.casillero_actual) < 1):
            self.casillero_actual = (self.casillero_actual[0] + 1,
                                     self.casillero_actual[1])
        if (self.casillero_actual in camino_6) and (self.camino_actual.index(
                self.casillero_actual) < 1):
            self.casillero_actual = (self.casillero_actual[0] - 1,
                                     self.casillero_actual[1])
        if (self.casillero_actual in camino_7) and (self.camino_actual.index(
                self.casillero_actual) < 1):
            self.casillero_actual = (self.casillero_actual[0] - 1,
                                     self.casillero_actual[1])
        if (self.casillero_actual in camino_8) and (self.camino_actual.index(
                self.casillero_actual) < 1):
            self.casillero_actual = (self.casillero_actual[0] + 1,
                                     self.casillero_actual[1])
        self.preguntar_accion()

    def guardar_tiempo(self):
        self.timer.stopTimer()
        self.tiempo_pasado = self.timer.getTime()
        self.datos[self.nombre]["tiempo"] = self.tiempo_pasado
        self.datos[self.nombre]["rayos"] = self.energia
        archivo = open('data/archivos/estadisticas.json', 'w')
        archivo.write(json.dumps(self.datos))
        archivo.close()

    def preguntar(self):
        def borrar1():
            self.izquierda.desactivar()
            self.izquierda.destruir()
            self.derecha.desactivar()
            self.derecha.destruir()
            self.cartel_bifurcacion.destruir()
            self.act()

        def borrar2():
            self.arriba.desactivar()
            self.arriba.destruir()
            self.izquierda.desactivar()
            self.izquierda.destruir()
            self.cartel_bifurcacion.destruir()
            self.act()

        def borrar3():
            self.arriba.desactivar()
            self.arriba.destruir()
            self.abajo.desactivar()
            self.abajo.destruir()
            self.cartel_bifurcacion.destruir()
            self.act()

        def bifurcacion1_izquierda():
            self.camino_actual = camino_1
            self.casillero_actual = self.camino_actual[0]
            borrar1()

        def bifurcacion1_derecha():
            self.camino_actual = camino_2
            self.casillero_actual = self.camino_actual[0]
            borrar1()

        def bifurcacion2_arriba():
            self.camino_actual = camino_3
            self.casillero_actual = self.camino_actual[0]
            borrar2()

        def bifurcacion2_izquierda():
            self.camino_actual = camino_4
            self.casillero_actual = self.camino_actual[0]
            borrar2()

        def bifurcacion3_arriba():
            self.camino_actual = camino_7
            self.casillero_actual = self.camino_actual[0]
            borrar2()

        def bifurcacion3_izquierda():
            self.camino_actual = camino_8
            self.casillero_actual = self.camino_actual[0]
            borrar2()

        def bifurcacion4_arriba():
            self.camino_actual = camino_5
            self.casillero_actual = self.camino_actual[0]
            borrar3()

        def bifurcacion4_abajo():
            self.camino_actual = camino_6
            self.casillero_actual = self.camino_actual[0]
            borrar3()

        self.cartel_bifurcacion = pilas.actores.Actor(
            'data/img/iconos/cartel_bifurcacion.png', x=8, y=100)
        self.cartel_bifurcacion.escala = 1
        if (self.casillero_actual == (391, -265)):
            self.izquierda = pilas.actores.Boton(x=10, y=175)
            self.izquierda.definir_imagen('data/img/interfaz/izquierda.png')
            self.izquierda.escala = 0.5
            self.derecha = pilas.actores.Boton(x=10, y=120)
            self.derecha.definir_imagen('data/img/interfaz/derecha.png')
            self.derecha.escala = 0.5
            self.izquierda.conectar_presionado(bifurcacion1_izquierda)
            self.derecha.conectar_presionado(bifurcacion1_derecha)
        if (self.casillero_actual == (131, -148)):
            self.arriba = pilas.actores.Boton(x=10, y=175)
            self.arriba.definir_imagen('data/img/interfaz/arriba.png')
            self.arriba.escala = 0.5
            self.izquierda = pilas.actores.Boton(x=10, y=120)
            self.izquierda.definir_imagen('data/img/interfaz/izquierda.png')
            self.izquierda.escala = 0.5
            self.arriba.conectar_presionado(bifurcacion2_arriba)
            self.izquierda.conectar_presionado(bifurcacion2_izquierda)
        if (self.casillero_actual == (133, -18)):
            self.arriba = pilas.actores.Boton(x=10, y=175)
            self.arriba.definir_imagen('data/img/interfaz/arriba.png')
            self.arriba.escala = 0.5
            self.izquierda = pilas.actores.Boton(x=10, y=120)
            self.izquierda.definir_imagen('data/img/interfaz/izquierda.png')
            self.izquierda.escala = 0.5
            self.arriba.conectar_presionado(bifurcacion3_arriba)
            self.izquierda.conectar_presionado(bifurcacion3_izquierda)
        if (self.casillero_actual == (-185, -151)):
            self.arriba = pilas.actores.Boton(x=10, y=175)
            self.arriba.definir_imagen('data/img/interfaz/arriba.png')
            self.arriba.escala = 0.5
            self.abajo = pilas.actores.Boton(x=10, y=120)
            self.abajo.definir_imagen('data/img/interfaz/abajo.png')
            self.abajo.escala = 0.5
            self.arriba.conectar_presionado(bifurcacion4_arriba)
            self.abajo.conectar_presionado(bifurcacion4_abajo)

    def verde(self):
        pilas.almacenar_escena(Adivinanza(self.nombre, self.datos))

    def naranja(self):
        pilas.almacenar_escena(Trabalenguas(self.nombre, self.datos))

    def violeta(self):
        pilas.almacenar_escena(Chistes())

    def ahorcado_juego(self):
        pilas.almacenar_escena(Ahorcado(self.nombre, self.datos))

    def preguntar_accion(self):
        if (self.casillero_actual in casilleros_bifurcacion):
            pilas.mundo.agregar_tarea(2.5, self.preguntar)
        elif (self.imagenes_posiciones[casilleros.index(
                self.casillero_actual)] == "data/img/iconos/pare.png"):
            pilas.mundo.agregar_tarea(2.5, self.retroceder)
            pilas.mundo.agregar_tarea(3, self.act)
        elif (self.imagenes_posiciones[casilleros.index(
                self.casillero_actual)] == "data/img/iconos/perder_vida.png"):
            pilas.mundo.agregar_tarea(2.3, self.perder_vida)
            pilas.mundo.agregar_tarea(2.5, self.act)
        elif (self.imagenes_posiciones[casilleros.index(self.casillero_actual)]
              == "data/img/iconos/teletransportacion.png"):
            pilas.mundo.agregar_tarea(2.5, self.teletransportacion)
            pilas.mundo.agregar_tarea(3, self.act)
        elif (self.imagenes_posiciones[casilleros.index(
                self.casillero_actual)] == "data/img/iconos/Casillero.png"):
            pilas.mundo.agregar_tarea(2.5, self.act)
        elif (self.imagenes_posiciones[casilleros.index(self.casillero_actual)]
              == "data/img/iconos/CasilleroVerde.png"):
            pilas.mundo.agregar_tarea(2.5, self.verde)
            pilas.mundo.agregar_tarea(3, self.actualizar_energia)
            pilas.mundo.agregar_tarea(3.2, self.act)
        elif (self.imagenes_posiciones[casilleros.index(self.casillero_actual)]
              == "data/img/iconos/CasilleroVioleta.png"):
            pilas.mundo.agregar_tarea(2, self.desactivar_sonido)
            pilas.mundo.agregar_tarea(2.5, self.violeta)
            pilas.mundo.agregar_tarea(3.4, self.ver_est)
            pilas.mundo.agregar_tarea(4, self.act)
        elif (self.imagenes_posiciones[casilleros.index(self.casillero_actual)]
              == "data/img/iconos/CasilleroNaranja.png"):
            pilas.mundo.agregar_tarea(2.5, self.naranja)
            pilas.mundo.agregar_tarea(3, self.actualizar_energia)
            pilas.mundo.agregar_tarea(3.2, self.act)
        elif (self.imagenes_posiciones[casilleros.index(
                self.casillero_actual)] == "data/img/iconos/ahorcado.png"):
            pilas.mundo.agregar_tarea(2.5, self.ahorcado_juego)
            pilas.mundo.agregar_tarea(3, self.actualizar_energia)
            pilas.mundo.agregar_tarea(3.2, self.act)
        elif (self.imagenes_posiciones[casilleros.index(self.casillero_actual)]
              == "data/img/iconos/Casillero_comodin.png"):

            def eliminar_cartel():
                self.boton_violeta.desactivar()
                self.boton_violeta.destruir()
                self.boton_naranja.desactivar()
                self.boton_naranja.destruir()
                self.boton_verde.desactivar()
                self.boton_verde.destruir()
                self.cartel_comodin.destruir()

            def conectar_violeta():
                pilas.mundo.agregar_tarea(1, self.desactivar_sonido)
                pilas.mundo.agregar_tarea(1.5, self.violeta)
                pilas.mundo.agregar_tarea(1.6, eliminar_cartel)
                pilas.mundo.agregar_tarea(1.7, self.ver_est)
                pilas.mundo.agregar_tarea(1.9, self.act)

            def conectar_naranja():
                pilas.mundo.agregar_tarea(1.5, self.naranja)
                pilas.mundo.agregar_tarea(1.6, eliminar_cartel)
                pilas.mundo.agregar_tarea(1.7, self.actualizar_energia)
                pilas.mundo.agregar_tarea(1.9, self.act)

            def conectar_verde():
                pilas.mundo.agregar_tarea(1.5, self.verde)
                pilas.mundo.agregar_tarea(1.6, eliminar_cartel)
                pilas.mundo.agregar_tarea(1.7, self.actualizar_energia)
                pilas.mundo.agregar_tarea(1.9, self.act)

            def generar_botones():
                #Boton violeta
                self.boton_violeta = pilas.actores.Boton(x=10, y=87)
                self.boton_violeta.definir_imagen(
                    'data/img/interfaz/boton_violeta.png')
                self.boton_violeta.escala = 0.7
                self.boton_violeta.conectar_presionado(conectar_violeta)
                #Boton naranja
                self.boton_naranja = pilas.actores.Boton(x=10, y=-65)
                self.boton_naranja.definir_imagen(
                    'data/img/interfaz/boton_naranja.png')
                self.boton_naranja.escala = 0.7
                self.boton_naranja.conectar_presionado(conectar_naranja)
                #Boton verde
                self.boton_verde = pilas.actores.Boton(x=16, y=-225)
                self.boton_verde.definir_imagen(
                    'data/img/interfaz/boton_verde.png')
                self.boton_verde.escala = 0.7
                self.boton_verde.conectar_presionado(conectar_verde)

            self.des()
            self.cartel_comodin = pilas.actores.Actor(
                'data/img/iconos/cartel_comodin.png', y=-70)
            self.cartel_comodin.escala = [2.5, 2], 0.8
            pilas.mundo.agregar_tarea(1, generar_botones)

    def mover(self, mov):
        mover_x = []
        mover_y = []
        for x in mov:
            mover_x.append(x[0])
            mover_y.append(x[1])
        self.personaje.x = pilas.interpolar(mover_x, 2)
        self.personaje.y = pilas.interpolar(mover_y, 2)

    def tirar_dado(self):
        self.sonido_dado.reproducir()
        n = self.dado.tirar()
        mov = []
        self.des()
        for x in range(n):
            #Movimiento en camino_1
            if (self.casillero_actual
                    in camino_1) and (self.camino_actual.index(
                        self.casillero_actual) < len(camino_1) - 1):
                i = self.camino_actual.index(self.casillero_actual) + 1
                self.casillero_actual = self.camino_actual[i]
                mov.append(self.casillero_actual)
            elif (self.casillero_actual
                  in camino_1) and (self.camino_actual.index(
                      self.casillero_actual) == len(camino_1) - 1) and (x < n):
                self.camino_actual = random.choice(sorteo_b2)
                self.casillero_actual = self.camino_actual[0]
                mov.append(self.casillero_actual)
            elif (self.casillero_actual
                  in camino_1) and (self.camino_actual.index(
                      self.casillero_actual) == len(camino_1) - 1) and (x
                                                                        == n):
                self.casillero_actual = casilleros_bifurcacion[1]
                mov.append(self.casillero_actual)
            #Movimiento en camino_2
            if (self.casillero_actual
                    in camino_2) and (self.camino_actual.index(
                        self.casillero_actual) < len(camino_2) - 1):
                i = self.camino_actual.index(self.casillero_actual) + 1
                self.casillero_actual = self.camino_actual[i]
                mov.append(self.casillero_actual)
            elif (self.casillero_actual
                  in camino_2) and (self.camino_actual.index(
                      self.casillero_actual) == len(camino_2) - 1) and (x < n):
                self.camino_actual = random.choice(sorteo_b3)
                self.casillero_actual = self.camino_actual[0]
                mov.append(self.casillero_actual)
            elif (self.casillero_actual
                  in camino_2) and (self.camino_actual.index(
                      self.casillero_actual) == len(camino_2) - 1) and (x
                                                                        == n):
                self.casillero_actual = casilleros_bifurcacion[2]
                mov.append(self.casillero_actual)
            #Movimiento en camino_3
            if (self.casillero_actual
                    in camino_3) and (self.camino_actual.index(
                        self.casillero_actual) < len(camino_3) - 1):
                i = self.camino_actual.index(self.casillero_actual) + 1
                self.casillero_actual = self.camino_actual[i]
                mov.append(self.casillero_actual)
            elif (self.casillero_actual
                  in camino_3) and (self.camino_actual.index(
                      self.casillero_actual) == len(camino_3) - 1) and (x < n):
                self.camino_actual = random.choice(sorteo_b3)
                self.casillero_actual = self.camino_actual[0]
                mov.append(self.casillero_actual)
            elif (self.casillero_actual
                  in camino_3) and (self.camino_actual.index(
                      self.casillero_actual) == len(camino_3) - 1) and (x
                                                                        == n):
                self.casillero_actual = casilleros_bifurcacion[2]
                mov.append(self.casillero_actual)
            #Movimiento en camino_4
            if (self.casillero_actual
                    in camino_4) and (self.camino_actual.index(
                        self.casillero_actual) < len(camino_4) - 1):
                i = self.camino_actual.index(self.casillero_actual) + 1
                self.casillero_actual = self.camino_actual[i]
                mov.append(self.casillero_actual)
            elif (self.casillero_actual
                  in camino_4) and (self.camino_actual.index(
                      self.casillero_actual) == len(camino_4) - 1) and (x < n):
                self.camino_actual = random.choice(sorteo_b4)
                self.casillero_actual = self.camino_actual[0]
                mov.append(self.casillero_actual)
            elif (self.casillero_actual
                  in camino_4) and (self.camino_actual.index(
                      self.casillero_actual) == len(camino_4) - 1) and (x
                                                                        == n):
                self.casillero_actual = casilleros_bifurcacion[3]
                mov.append(self.casillero_actual)
            #Movimiento en camino_5
            if (self.casillero_actual
                    in camino_5) and (self.camino_actual.index(
                        self.casillero_actual) < len(camino_5) - 1):
                i = self.camino_actual.index(self.casillero_actual) + 1
                self.casillero_actual = self.camino_actual[i]
                mov.append(self.casillero_actual)
            elif (self.casillero_actual
                  in camino_5) and (self.camino_actual.index(
                      self.casillero_actual) == len(camino_5) - 1):
                self.casillero_actual = casillero_castillo
                mov.append(self.casillero_actual)
                break
            #Movimiento en camino_6
            if (self.casillero_actual
                    in camino_6) and (self.camino_actual.index(
                        self.casillero_actual) < len(camino_6) - 1):
                i = self.camino_actual.index(self.casillero_actual) + 1
                self.casillero_actual = self.camino_actual[i]
                mov.append(self.casillero_actual)
            elif (self.casillero_actual
                  in camino_6) and (self.camino_actual.index(
                      self.casillero_actual) == len(camino_6) - 1):
                self.casillero_actual = casillero_castillo
                mov.append(self.casillero_actual)
                break
            #Movimiento en camino_7
            if (self.casillero_actual
                    in camino_7) and (self.camino_actual.index(
                        self.casillero_actual) < len(camino_7) - 1):
                i = self.camino_actual.index(self.casillero_actual) + 1
                self.casillero_actual = self.camino_actual[i]
                mov.append(self.casillero_actual)
            elif (self.casillero_actual
                  in camino_7) and (self.camino_actual.index(
                      self.casillero_actual) == len(camino_7) - 1):
                self.casillero_actual = casillero_castillo
                mov.append(self.casillero_actual)
                break
            #Movimiento en camino_8
            if (self.casillero_actual
                    in camino_8) and (self.camino_actual.index(
                        self.casillero_actual) < len(camino_8) - 1):
                i = self.camino_actual.index(self.casillero_actual) + 1
                self.casillero_actual = self.camino_actual[i]
                mov.append(self.casillero_actual)
            elif (self.casillero_actual
                  in camino_8) and (self.camino_actual.index(
                      self.casillero_actual) == len(camino_8) - 1):
                self.casillero_actual = casillero_castillo
                mov.append(self.casillero_actual)
                break
            #Movimiento inicial
            if (self.casillero_actual == casillero_mapa) and (n > 1):
                self.camino_actual = random.choice(sorteo_b1)
                self.casillero_actual = self.camino_actual[0]
                mov.append(self.casillero_actual)
            elif (self.casillero_actual == casillero_mapa) and (n == 1):
                self.casillero_actual = casilleros_bifurcacion[0]
                mov.append(self.casillero_actual)
    #Parche para que funcione adecuamente el camino 3 con la bifurcacion
        if (self.casillero_actual in camino_3) and (self.camino_actual.index(
                self.casillero_actual) > 1):
            self.casillero_actual = (self.casillero_actual[0],
                                     self.casillero_actual[1] - 1)
    #Parche para que funcionen adecuadamente los caminos 5 y 6 con los juegos
        if (self.casillero_actual in camino_5) and (self.camino_actual.index(
                self.casillero_actual) > 1):
            self.casillero_actual = (self.casillero_actual[0] - 1,
                                     self.casillero_actual[1])
            self.camino_actual = camino_8
        if (self.casillero_actual in camino_6) and (self.camino_actual.index(
                self.casillero_actual) > 9):
            self.casillero_actual = (self.casillero_actual[0] + 1,
                                     self.casillero_actual[1])
            self.camino_actual = camino_8
    #Parche para que funcione adecuadamente el casillero castillo
        if (self.casillero_actual in camino_8) and (self.camino_actual.index(
                self.casillero_actual) > 14):
            self.casillero_actual = (self.casillero_actual[0],
                                     self.casillero_actual[1] - 1)

    #Movimiento
        self.mover(mov)
        #Final
        if (self.casillero_actual == casillero_castillo):
            pilas.mundo.agregar_tarea(2.5, self.gano)
        else:
            #Acciones a realizar al caer en un casillero determinado
            self.preguntar_accion()
示例#4
0
class Trabalenguas(Base):
    def __init__(self, nombre, datos):
        Base.__init__(self)
        self.nombre = nombre
        self.datos = datos

    def iniciar(self):
        self.fondo()
        self.explicacion()

    def fondo(self):
        pilas.fondos.Fondo('data/img/fondos/trabalenguas.jpg')

    def explicacion(self):
        self.titulo = pilas.actores.Actor(
            "data/img/enunciados/trabalenguas.png", y=200)
        self.titulo.escala = 0.5
        self.explicacion_texto = pilas.actores.Actor(
            "data/img/interfaz/enunciado_trabalenguas.png")
        self.explicacion_texto.escala = 0.8
        pilas.mundo.agregar_tarea(7, self.mostrar)

    def mostrar(self):
        self.explicacion_texto.eliminar()
        self.indice = random.randrange(0, 12)
        self.recuadro = pilas.actores.Actor("data/img/interfaz/recuadrito.png",
                                            x=-20,
                                            y=-20)
        self.recuadro.escala = 0.45
        self.texto = pilas.actores.Texto(
            trabalenguas[self.indice],
            fuente="data/fonts/American Captain.ttf",
            ancho=256)
        self.texto.color = pilas.colores.negro
        pilas.mundo.agregar_tarea(10, self.seguir)

    def seguir(self):
        self.time = Temporizador(x=-300, y=300)
        self.time.setDatas(0)
        self.time.iniciar_aum()
        self.texto.eliminar()
        self.texto_nuevo = pilas.actores.Texto(
            problemas[self.indice],
            fuente="data/fonts/American Captain.ttf",
            ancho=256)
        self.texto_nuevo.color = pilas.colores.negro
        self.personaje = pilas.actores.Actor("data/img/iconos/character.png",
                                             x=700)
        self.personaje.escala = 0.3
        self.personaje.x = [400]
        self.personaje.y = [-200]
        self.mostrar_incorrecto()

    def verificar(self, respuesta):
        respuestas = {
            "%s / %s" % (trabalenguas_solucion[self.indice][0], trabalenguas_solucion[self.indice][1]):
            "correcto",
            "%s / %s" % (trabalenguas_solucion[self.indice][0], trabalenguas_solucion[self.indice][2]):
            "incorrecto",
            "%s / %s" % (trabalenguas_solucion[self.indice][1], trabalenguas_solucion[self.indice][2]):
            "incorrecto"
        }
        if (respuestas[respuesta] == "correcto"):
            self.personaje.decir("Bien hecho , era la respuesta correcta")
            self.ener = True
        else:
            self.personaje.decir(
                "Respuesta incorrecta , mejor suerte la proxima")
            self.ener = False
        pilas.mundo.agregar_tarea(2, self.volver)

    def mostrar_incorrecto(self):
        dialogo = pilas.actores.Dialogo()
        respuesta_correcta = "%s / %s" % (trabalenguas_solucion[
            self.indice][0], trabalenguas_solucion[self.indice][1])
        respuesta_incorrecta1 = "%s / %s" % (trabalenguas_solucion[
            self.indice][0], trabalenguas_solucion[self.indice][2])
        respuesta_incorrecta2 = "%s / %s" % (trabalenguas_solucion[
            self.indice][1], trabalenguas_solucion[self.indice][2])
        self.opciones = [
            respuesta_correcta, respuesta_incorrecta1, respuesta_incorrecta2
        ]
        random.shuffle(self.opciones)
        dialogo.elegir(self.personaje, "Que palabras faltan?", self.opciones,
                       self.verificar)
        pilas.mundo.agregar_tarea(2, dialogo.iniciar)

    def volver(self):
        self.time.stopTimer()
        self.datos[self.nombre]['tiempo_trabalenguas'][0] = self.datos[
            self.nombre]['tiempo_trabalenguas'][0] + self.time.getTime()
        self.datos[self.nombre]['tiempo_trabalenguas'][1] = self.datos[
            self.nombre]['tiempo_trabalenguas'][1] + 1
        if (self.ener == False):
            self.datos[self.nombre]['tiempo_trabalenguas'][2] = self.datos[
                self.nombre]['tiempo_trabalenguas'][2] + 1
        f = open("data/archivos/estadisticas.json", "w")
        f.write(json.dumps(self.datos))
        f.close()
        e = open("data/archivos/energia.txt", 'wb')
        pickle.dump(self.ener, e)
        e.close()
        pilas.recuperar_escena()