Exemple #1
0
class estado(pantalla.Pantalla):
    tiempo = 0
    reloj = pygame.time.Clock()
    anim_fondo = RenderAnim()
    grupo_botones = RenderBoton()
    grupo_personaje = RenderChar()
    sprite = pygame.sprite.Sprite()
    marcador = pygame.sprite.Sprite()
    limites = pygame.sprite.Group()
    grupo_objetos = pygame.sprite.Group()
    grupo_marcadores = pygame.sprite.Group()
    grupo_popup =  pygame.sprite.OrderedUpdates()
    grupo_imagenes = pygame.sprite.OrderedUpdates()
    foobar = True
    ayuda = False
    choque = False
    marker = False
    completado = False
    final_cont  = True
    inicio_cont = False
    texto_visible = False
    leer_ubicacion = False
    servidor_callado = True
    explicar_sonidos = False
    nivel = 1
    respuesta = 2
    vel_nube = -2
    nivel_actual = 1
    
    def __init__(self, parent):
        """
        Método inicializador de la clase. 
        
        @param parent: Instancia del gestor de pantallas.
        @type parent: Manejador
        """
        self.apla = pygame.image.load(self.pops + "aplaudiendo.png").convert_alpha()
        self.pensa = pygame.image.load(self.pops + "pensando.png").convert_alpha()
        poporquidea = pygame.image.load(self.pops + "orquidea.png").convert_alpha()
        popapamate = pygame.image.load(self.pops + "popupapamate.png").convert_alpha()
        poparaguaney = pygame.image.load(self.pops + "popuparaguaney.png").convert_alpha()
        popclorofila = pygame.image.load(self.pops + "popupclorofila.png").convert_alpha()
        popinjerto = pygame.image.load(self.pops + "popupinjerto.png").convert_alpha()
        poprepro = pygame.image.load(self.pops + "popupreproduccion.png").convert_alpha()
        popportu = pygame.image.load(self.pops + "portu.png").convert_alpha()
        popacodo = pygame.image.load(self.pops + "popuacodo.png").convert_alpha()
        popmango = pygame.image.load(self.pops + "popumango.png").convert_alpha()
        popyuca = pygame.image.load(self.pops + "popuyuca.png").convert_alpha()
        self.img_pistas = {
            0: poparaguaney,
            1: popapamate,
            2: popclorofila,
            3: poporquidea,
            4: poprepro,
            5: popyuca,
            6: popmango,
            7: popportu,
            8: popacodo,
            9: popinjerto
        }
        esc = pygame.image.load(self.pops + "esc.png").convert_alpha()
        raton = pygame.image.load(self.pops + "touch.png").convert_alpha()
        salir = pygame.image.load(self.pops + "boton-salir.png").convert_alpha()
        enter = pygame.image.load(self.pops + "enter.png").convert_alpha()
        teclado = pygame.image.load(self.pops + "flechas.png").convert_alpha()
        f1 = pygame.image.load(self.pops + "f1.png").convert_alpha()
        self.img_textos = {"ENTER" : enter, "TECLADO": teclado, "F1": f1, "ESC": esc, "SALIR": salir, "RATON":raton}
        self.raton = cursor()
        self.parent = parent
        self.visor = self.parent.screen
        pygame.display.set_caption('Siembra la semilla')
        self.flecha_verde = pygame.image.load(self.varios + "flecha-verde.png").convert_alpha()
        self.preguntas = prp()
        self.casa = imagen(self.varios + "casa.png", 0, 70)
        self.poste = imagen(self.varios + "poste.png", 880, 0)
        self.tractor = imagen(self.varios +"tractor.png", 840, 80)
        self.pala = objeto(590, 380, self.varios + "pala.png", "la pala. ")
        self.abono = objeto(900, 305, self.varios + "abono.png", "el abono. ")
        self.carre = objeto(200, 80, self.varios + "carre.png", "la carretilla. ")
        self.insec = objeto(760, 140, self.varios + "insec.png", u"el controlador biológico. ")
        self.regadera = objeto(792, 270, self.varios + "regadera.png", "la regadera. ")
        self.semillas = objeto(450, 200, self.varios + "semillas.png", "las semillas. ")
        self.nubes = animacion("nubes", self.varios + "nubes.png", 1, 1, 30, -15, -1, False, 18)
        self.salir = boton("salir", "Salir", self.botones + "boton-salir.png", 1, 830, 60, -1, False, 1)
        self.flecha = animacion("flecha", self.varios + "flecha-verde.png", 3, 1, 800, 350, -1, True, 6)
        self.flores = animacion("flores", self.varios + "campo-flores.png", 4, 1, 758, 290, -1, False, 18)
        self.siembra = animacion("siembra", self.varios + "cinta-campesino.png", 3, 1, 680, 250, -1, True, 9)
        self.granjero = personaje(200, 128, self.varios + "0.png", 2)
        self.popup_respuesta = PopUp(parent, ("Respuesta " ), "Aceptar", self.flecha_verde, self.grupo_popup)
        self.popup_pregunta = PopUp(parent, ("Pregunta ", "p1 ", "p2 ", "p3 " ), "Aceptar", 0, self.grupo_popup, 1)
        self.popup_ayuda = PopUp(parent, self.preguntas.instruc[0], "", self.img_textos , self.grupo_popup, 2, 512, 214, 100)
        self.popup_instruc = PopUp(parent, u"    Pulsa la tecla F1 para activar o desactivar las instrucciones del juego. ", "", self.img_textos , self.grupo_popup, 2, 240, 482, -160)
        self.popup_final1 = PopUp(self.parent, (u"    ¡Muy bien! Has finalizado el primer nivel. ", ), "Aceptar", self.apla, self.grupo_popup)
        self.update()
        
    def limpiar_grupos(self):
        """Limpia los elementos de una pantalla. """
        self.grupo_personaje.empty()
        self.grupo_imagenes.empty()
        self.grupo_objetos.empty()
        self.grupo_personaje.empty()
        self.grupo_botones.empty()
        self.anim_fondo.empty()
        self.grupo_popup.empty()
        
    def nivel1(self):
        """
        Carga las imágenes e inicializa los objetos del nivel 1 de la actividad número 1.
        """
        self.preguntas.__init__()
        self.nivel_actual = 1
        self.completado = False
        self.foobar = True
        self.ayuda = False
        self.fondo = pygame.image.load(self.varios + "fondo1.png").convert()
        self.limpiar_grupos()
        self.anim_fondo.empty()
        self.poste.reubicar(880, 0)
        self.tractor.reubicar(840, 80)
        self.semillas.reubicar(450, 200)
        self.regadera.reubicar(880, 270)
        self.meta = pygame.Rect(800, 470, 50, 100)
        self.grupo_marcadores.empty()
        self.m_semilla = marcador((357, 314, 20, 20), "semilla")
        self.sem_rec = marcador((357, 234, 20, 20), "semilla1")
        self.m_rega = marcador((664, 314, 20, 20), "regadera")
        self.rega_rec = marcador((786, 314, 20, 20), "regadera1")
        self.m_pala = marcador((501, 314, 20, 20), "pala")
        self.grupo_marcadores.add(self.m_semilla, self.m_rega)
        self.limites.empty()
        self.limites.add(limite((167, 267, 170, 20), 1), limite((317, 196, 20, 91), 2), limite((317, 196, 113, 20), 3),
                         limite((410, 196, 20, 91), 4), limite((410, 267, 430, 20), 5), limite((167, 267, 20, 117), 6),
                         limite((820, 267, 20, 117), 7), limite((167, 364, 310, 20), 8), limite((550, 364, 290, 20), 9), 
                         limite((457, 364, 20, 208), 10), limite((550, 364, 20, 122), 11), limite((550, 466, 169, 20), 12), 
                         limite((699, 466, 20, 106), 13), limite((457, 552, 262, 20), 14) )
        self.granjero.por_defecto(170, 128, self.varios + "0.png", 2, self.limites)
        self.grupo_personaje.add(self.granjero)
        self.granjero.actualizar_rects()
        self.grupo_objetos.add(self.semillas, self.regadera, self.pala)
        self.grupo_imagenes.add(self.tractor, self.poste, self.casa)
        self.grupo_botones.add(self.salir)
        self.anim_fondo.add(self.nubes, self.flores)
        self.popup_instruc.agregar_grupo()
        self.flores.detener()
        self.mostrar_ayuda()
        if self.parent.config.activar_lector:
            self.limites.add(limite((477, 365, 73, 20), 15))
        
    def nivel2(self):
        """
        Carga las imágenes e inicializa los objetos del nivel 1 de la actividad número 1.
        """
        self.nivel_actual = 2
        self.completado = False
        self.foobar = True
        self.ayuda = False
        self.fondo = pygame.image.load(self.varios + "fondo2.png").convert()
        self.limpiar_grupos()
        self.poste.reubicar(880, -70)
        self.tractor.reubicar(840, 20)
        self.semillas.reubicar(290, 300)
        self.regadera.reubicar(495, 125)
        self.meta = pygame.Rect(800, 400, 50, 80)
        self.grupo_marcadores.empty()
        self.m_sem_car = marcador((206, 246, 20, 20), "sem_car")
        self.m_rega = marcador((424, 246, 20, 20), "regadera")
        self.m_pala = marcador((510, 246, 20, 20), "pala")
        self.m_insec = marcador((645, 246, 20, 20), "insec")
        self.m_abono = marcador((808, 246, 20, 20), "abono")
        self.sem_rec = marcador((206, 315, 20, 20), "semillas1")
        self.rega_rec = marcador((424, 180, 20, 20), "regadera1")
        self.carre_rec = marcador((206, 180, 20, 20), "carretilla1")
        self.insect_rec = marcador((645, 180, 20, 20), "insect1")
        self.abono_rec = marcador((808, 315, 20, 20), "abono1")
        self.limites.empty()
        self.limites.add(limite((153, 124, 20, 259), 1), limite((153, 124, 113, 20), 2), limite((246, 124, 20, 92), 3), 
                         limite((246, 196, 151, 20), 4), limite((377, 124, 20, 92), 5), limite((377, 124, 113, 20), 6),
                         limite((470, 124, 20, 92), 7), limite((470, 196, 148, 20), 8), limite((598, 124, 20, 92), 9),
                         limite((598, 124, 117, 20), 10), limite((695, 124, 20, 92), 11), limite((695, 196, 177, 20), 12), 
                         limite((852, 196, 20, 187), 13), limite((760, 363, 112, 20), 13), limite((760, 293, 20, 90), 14), 
                         limite((555, 293, 225, 20), 15), limite((555, 293, 20, 120), 16), limite((555, 393, 170, 20), 17), 
                         limite((705, 393, 20, 118), 18), limite((463, 491, 262, 20), 19), limite((463, 293, 20, 218), 20), 
                         limite((246, 293, 237, 20), 21), limite((246, 293, 20, 90), 22), limite((153, 363, 113, 20), 23),
                         )
        self.granjero.por_defecto(150, 50, self.varios + "-1.png", 2, self.limites)
        self.granjero.actualizar_rects()
        self.granjero.codigo = -1
        self.grupo_personaje.add(self.granjero)
        self.grupo_objetos.add(self.carre, self.pala, self.regadera, self.semillas, self.abono, self.insec)
        self.grupo_imagenes.add(self.tractor, self.poste)
        self.anim_fondo.add(self.nubes, self.flores)
        self.popup_instruc.agregar_grupo()
        self.grupo_botones.add(self.salir)
        self.flores.detener()
        if self.parent.config.activar_lector:
            self.limites.add(limite((483, 294, 72, 20), 24)) # Ladrillo invisible
            self.pista_sonidos()
        
    def mostrar_ayuda(self):
        """
        Muestra las instrucciones de uso de la actividad 1.
        """
        if self.ayuda == False:
            self.popup_ayuda.agregar_grupo()
            self.spserver.processtext(self.preguntas.instruc[1], self.parent.config.activar_lector)
            self.ayuda = True
        else:
            self.popup_ayuda.eliminar_grupo()
            self.spserver.stopserver()
            self.ayuda = False
            if self.popup_pregunta.activo:
                self.leer_respuestas(self.preguntas.dic_pre[self.preguntas.valor], self.preguntas.dic_res[self.preguntas.valor], True)
            elif self.popup_respuesta.activo:
                self.spserver.processtext(self.preguntas.dic_pistas[self.preguntas.valor][self.cache_click] + "Pulsa Enter para continuar. ", self.parent.config.activar_lector)
                
    def pista_sonidos(self):
        """
        Indica el momento en el que inicia un contador para sincronizar el sintetizador de voz
        con los sonidos de instrucción.
        """
        self.contador = pygame.time.Clock()
        self.contador.tick(30)
        self.inicio_cont = True
        self.final_cont = False
        
    def handleEvents(self, eventos):         
        """
        Evalúa los eventos que se generan en esta pantalla.        

        @param eventos: Lista de los eventos.
        @type eventos: list
        """  
        self.teclasPulsadas = pygame.key.get_pressed()
        for evento in eventos:
            if evento.type == pygame.KEYDOWN and evento.key == pygame.K_ESCAPE:
                self.parent.popState()
                
            if evento.type == pygame.QUIT:
                self.parent.quit()
   
            if evento.type == pygame.KEYDOWN and evento.key == pygame.K_F1:
                if not self.completado:
                    self.mostrar_ayuda()
                
                if not self.explicar_sonidos and self.parent.config.activar_lector:
                    self.popup_ayuda.eliminar_grupo()
                    self.draw()
                    self.pista_sonidos()
                    self.explicar_sonidos = True
                
            if pygame.sprite.spritecollideany(self.raton, self.grupo_botones):
                sprite = pygame.sprite.spritecollide(self.raton, self.grupo_botones, False)
                if evento.type == pygame.MOUSEBUTTONDOWN and evento.button == 1:
                    if sprite[0].id == "salir":
                        self.parent.popState()
            
            if self.popup_pregunta.activo and not self.popup_ayuda.activo:
                self.popup_respuesta = PopUp(self.parent, ("Respuesta " ), "Aceptar", self.flecha_verde, self.grupo_popup)
                self.popup_pregunta.manejador_eventos(evento)       
                if self.teclasPulsadas[pygame.K_1] and self.choque:
                    self.evaluar_respuesta(0)
                elif self.teclasPulsadas[pygame.K_2] and self.choque:
                    self.evaluar_respuesta(1)
                elif self.teclasPulsadas[pygame.K_3] and self.choque:
                    self.evaluar_respuesta(2)
                elif self.popup_pregunta.evaluar_click() != -1:
                    self.evaluar_respuesta(self.popup_pregunta.evaluar_click())
            
            if self.popup_respuesta.activo and not self.popup_ayuda.activo:
                self.popup_pregunta.manejador_eventos(evento)
                self.popup_respuesta.manejador_eventos(evento)
                self.popup_pregunta.activo = False
                self.granjero.ocupado = True
                if self.teclasPulsadas[pygame.K_RETURN] or self.popup_respuesta.evaluar_click() != -1:
                    if self.respuesta == 1: 
                        self.actualizar_pj()
                        self.popup_respuesta.eliminar_grupo()
                        self.popup_pregunta.eliminar_grupo()
                    elif self.respuesta == 0: 
                        self.popup_pregunta.activo = True    
                        self.leer_respuestas(self.preguntas.dic_pre[self.preguntas.valor], self.preguntas.dic_res[self.preguntas.valor], True)
                        self.popup_respuesta.eliminar_grupo()
                    self.granjero.ocupado = False
                    self.respuesta = 2
        
            if self.popup_final1.activo:
                self.granjero.ocupado = True
                self.popup_final1.manejador_eventos(evento)
                if self.teclasPulsadas[pygame.K_RETURN] or self.popup_final1.evaluar_click() != -1:
                    self.popup_final1.eliminar_grupo()
                    self.granjero.ocupado = False
                    self.nivel = 2
                    
        if not self.popup_ayuda.activo and not self.completado :
            self.granjero.update()
        self.detectar_colision()
        self.colision_marcador()
        if self.parent.config.activar_lector:
            self.actualizar_marcadores()
        self.contar()
        self.logica()
        
    def update(self):
        """
        Verifica el cambio de nivel de la actividad 1.
        """
        if self.nivel == 1:
            self.nivel1()
            self.nivel = 0
        elif self.nivel == 2:
            self.nivel2()
            self.nivel = 0
            
    def contar(self):
        """
        Una vez se llama la función pista_sonidos(), se mide el tiempo transcurrido y en los intervalos definidos
        se enviá información al sintetizador de voz, seguidamente se reproduce el sonido asociado a la 
        instrucción.
        """
        if self.inicio_cont and not self.final_cont:
            if self.nivel_actual == 1:
                self.granjero.ocupado = True
                if self.tiempo > 21000:
                    self.tiempo = 0
                    self.ayuda = False
                    self.final_cont = True
                    self.granjero.ocupado = False
                else:
                    self.tiempo += self.contador.get_time()
                    
                if self.tiempo in range(1033, 1066):
                    self.ayuda = True
                    self.spserver.processtext(u"Este sonido te indica que vas por el camino correcto. ", self.parent.config.activar_lector)
                    
                elif self.tiempo in range(6000, 6033):
                    self.granjero.sonido_caminar.play(5)
                     
                elif self.tiempo in range(8000, 8033):
                    self.spserver.processtext(u"Este sonido te indica que has encontrado un obstáculo. ", self.parent.config.activar_lector)
                    
                elif self.tiempo in range(13000, 13033):
                    self.granjero.sonido_choque.play(5)
                    
                elif self.tiempo in range(14000, 14033):
                    self.spserver.processtext(u"Te encuentras en el primer nivel, muévete hacia la derecha para comenzar. ", self.parent.config.activar_lector)
                    
            elif self.nivel_actual == 2:
                self.granjero.ocupado = True
                if self.tiempo > 13000:
                    self.tiempo = 0
                    self.ayuda = False
                    self.final_cont = True
                    self.granjero.ocupado = False
                    self.grupo_marcadores.add(self.m_sem_car, self.m_rega, self.m_abono, self.m_insec)
                else:
                    self.tiempo += self.contador.get_time()
                
                if self.tiempo in range(1033, 1066):
                    self.ayuda = True
                    self.spserver.processtext(u"Te encuentras en el nivel 2. Busca la carretilla " 
                                              u"y luego recolecta los elementos necesarios para la siembra. ",
                                              self.parent.config.activar_lector)
                
    def logica(self): 
        """
        Define y gestiona las condiciones para completar los niveles 1 y 2 de la actividad 1.
        """       
        if (self.granjero.codigo == 7 and self.nivel_actual == 1) or (self.nivel_actual == 2 and self.granjero.codigo >= 31):  
            if not self.completado:
                self.anim_fondo.add(self.flecha)
                if self.parent.config.activar_lector and self.foobar:
                    self.ayuda = True
                    self.spserver.processtext(u"Has recolectado todos los elementos de este nivel, avanza hasta el sembradío para completar la siembra. " , self.parent.config.activar_lector)
                    if self.nivel_actual == 1:
                        self.granjero.reubicar(460, 300)
                    elif self.nivel_actual == 2:
                        self.granjero.reubicar(460, 260)
                    self.foobar = False
                    
        if self.marker and self.parent.config.activar_lector:
            self.leer_marcador()
        else:
            self.leer_ubicacion = False
              
        if self.choque:
            self.mostrar_pregunta()
        else:
            if not self.ayuda and not self.marker and self.spserver.hablando:
                self.spserver.stopserver()
                
            self.texto_visible = False
            self.popup_pregunta.eliminar_grupo()
           
        if self.meta.colliderect(self.granjero.rt_car) and self.granjero.codigo == 7 and self.nivel_actual == 1:
            self.flores.continuar()
            self.anim_fondo.add(self.siembra)
            self.anim_fondo.remove(self.flecha)
            self.grupo_personaje.remove(self.granjero)
            self.meta = pygame.Rect(0, 0, 1, 1)
            self.completado = True
            self.ayuda = True
            self.popup_final1.agregar_grupo()
            self.spserver.processtext(u"¡Muy bien! Has finalizado el primer nivel. Pulsa Enter para continuar. " , self.parent.config.activar_lector)
            
        if self.meta.colliderect(self.granjero.rt_car) and self.granjero.codigo == 31 and self.nivel_actual == 2:
            self.flores.continuar()
            self.anim_fondo.add(self.siembra)
            self.anim_fondo.remove(self.flecha)
            self.grupo_personaje.remove(self.granjero)
            self.meta = pygame.Rect(0, 0, 1, 1)
            self.completado = True
            self.ayuda = True
            self.popup_instruc.eliminar_grupo()
            self.popup_instruc = PopUp(self.parent, u"    ¡Excelente! Pulsa la tecla ESC o sobre el botón SALIR para ir al menú principal. ", "", self.img_textos , self.grupo_popup, 2, 240, 440, -160)
            self.popup_instruc.agregar_grupo()
            self.spserver.processtext(u"¡Excelente! Pulsa la tecla escape " 
            u"o sobre el botón salir para ir al menú principal. ", self.parent.config.activar_lector)
            
    def evaluar_respuesta(self, valor):
        """
        Verifica si la opción seleccionada es la correcta. Muestra un mensaje emergente indicando si es o no 
        correcto, adicionalmente si esta activado el sintetizador de voz, leerá el contenido del mensaje 
        emergente.
        
        @param valor: Opción elegida por el usuario.
        @type valor: int
        """
        self.cache_click = valor
        try:
            respuesta = self.preguntas.dic_res[self.preguntas.valor][valor]
            if respuesta == self.preguntas.r_correcta[self.preguntas.valor]:
                self.respuesta = 1
                self.popup_respuesta = PopUp(self.parent, (self.preguntas.dic_pistas[self.preguntas.valor][valor], ), "Aceptar", ( self.img_pistas[self.preguntas.valor], self.apla)  , self.grupo_popup, 0 , 512, 400 )
            else:
                self.respuesta = 0
                self.popup_respuesta = PopUp(self.parent, (self.preguntas.dic_pistas[self.preguntas.valor][valor], ), "Aceptar",  self.pensa, self.grupo_popup, 0, 512, 400)
            self.spserver.processtext(self.preguntas.dic_pistas[self.preguntas.valor][valor] + "Pulsa Enter para continuar. ", self.parent.config.activar_lector)            
            self.popup_respuesta.agregar_grupo()
        except:
            print "Valor fuera de rango"
    
    def det_msj_n1(self):
        """
        Determina la instrucción que leerá el sintetizador de voz al pasar sobre un marcador
        de posición del nivel 1, a partir del código del personaje.
        @return: Código correspondiente a la instrucción que leerá el sintetizador de voz.
        @rtype: int 
        """
        if self.marcador.id == "semilla":
            if self.granjero.codigo in [0,2]:
                return 0
            elif self.granjero.codigo == 1:
                return 1 
            else:
                return 2
          
        elif self.marcador.id == "regadera":
            if self.granjero.codigo in [0,1]:
                return 0
            elif self.granjero.codigo == 2:
                return 1
            else:
                return 2
        
        elif self.marcador.id == "pala":
            if self.granjero.codigo >= 3:
                return 0
            else:
                return 1
            
        elif self.marcador.id in ["semilla1", "regadera1"]:
            return 0
        
        else:
            return 0
        
    def det_msj_n2(self):
        """
        Determina la instrucción que leerá el sintetizador de voz al pasar sobre un marcador
        de posición del nivel 2, a partir del código del personaje.
        @return: Código correspondiente a la instrucción que leerá el sintetizador de voz.
        @rtype: int 
        """
        if self.marcador.id == "sem_car":
            if self.granjero.codigo == -1:
                return 2
            elif self.granjero.codigo in range(0, 31, 2):
                return 0
            else:
                return 1
        
        elif self.marcador.id == "regadera":
            if self.granjero.codigo in [0, 1, 4, 5, 8, 9, 12, 13, 16, 17, 20, 21, 24, 25, 28, 29]:
                return 0
            elif self.granjero.codigo in [3, 9, 13, 21, 25 ]:
                return 1
            else:
                return 2
        
        elif self.marcador.id == "pala":
            if self.granjero.codigo == 27:
                return 0
            else:
                return 1
        
        elif self.marcador.id == "abono":
            if self.granjero.codigo in range(0, 8) or self.granjero.codigo in range(16, 24):
                return 0
            elif self.granjero.codigo != 19:
                return 1
            else:
                return 2
        
        elif self.marcador.id == "insec":
            if self.granjero.codigo < 16:
                return 0
            elif self.granjero.codigo not in [3, 7, 11, 15, 19, 23, 27]:
                return 1
            elif self.granjero.codigo == 19:
                return 2
            else:
                return 3
        
        elif self.marcador.id in ["abono1", "insect1", "regadera1", "semillas1", "carretilla1"]:
            return 0    
        
        else:
            return 0
            
    def leer_marcador(self):
        """
        Solicita el sintetizador de voz que lea la instrucción correspondiente al marcador donde esta ubicado
        el personaje.
        """
        if not self.leer_ubicacion:
            if self.nivel_actual == 1:
                self.spserver.processtext(self.preguntas.marcas_n1[self.marcador.id][self.det_msj_n1()], self.parent.config.activar_lector)
            elif self.nivel_actual == 2:
                self.spserver.processtext(self.preguntas.marcas_n2[self.marcador.id][self.det_msj_n2()], self.parent.config.activar_lector)
            self.leer_ubicacion = True
            
    def leer_respuestas(self, pregunta, respuestas, repetir = False):
        """
        Solicita al sintetizador de voz que lea una cadena de texto compuesta por: La indicación del elemento
        encontrado, el enunciado y las respuestas posibles.
        @param pregunta: Enunciado correspondiente al objeto encontrado.
        @type pregunta: str
        @param respuestas: Lista de respuestas posibles.
        @type respuestas: list
        @param repetir: Indica si se debe repetir, en caso de que la respuesta sea incorrecta.
        @type repetir: bool
        """
        texto = u""
        for i in respuestas:
            texto += u"opción número:" + i
        if repetir:
            final = u"Selecciona la opción que corresponde al siguiente enunciado: " +  pregunta + u":" + texto
        else:
            final = u"Has encontrado: " + self.sprite.nombre + u"Selecciona la opción que corresponde al siguiente enunciado:" +  pregunta + u":" + texto
        self.spserver.processtext(final, self.parent.config.activar_lector)
        
    def actualizar_pj(self):
        """
        Actualiza la imagen y código del personaje. Elimina el objeto encontrado del grupo de sprites.
        """
        self.granjero.codigo += self.sprite.aumento
        self.preguntas.quitar_pregunta(self.preguntas.valor)
        self.granjero.cambiar_imagen(self.granjero.dic_imagenes[self.granjero.codigo])
        self.grupo_objetos.remove(self.sprite)
        if self.nivel_actual == 1:
            if self.granjero.codigo in [1, 3, 5]:
                self.grupo_marcadores.add(self.sem_rec)
            if self.granjero.codigo in [2, 3, 6]: 
                self.grupo_marcadores.add(self.rega_rec)
                
        if self.nivel_actual == 2:
            if self.granjero.codigo == 0:
                self.grupo_marcadores.add(self.carre_rec)
            if self.granjero.codigo in range(1, 32, 2):
                self.grupo_marcadores.add(self.sem_rec)
            if self.granjero.codigo not in [0, 1, 4, 5, 8, 9, 12, 13, 16, 17, 20, 21, 24, 25, 28, 29]:
                self.grupo_marcadores.add(self.rega_rec)
            if self.granjero.codigo in range(8, 15) or self.granjero.codigo in range(24, 31):
                self.grupo_marcadores.add(self.abono_rec)
            if self.granjero.codigo in range(17, 31):
                self.grupo_marcadores.add(self.insect_rec)
                
    def actualizar_marcadores(self):
        """
        Actualiza la instrucción de los marcadores de posición en función del código del personaje.
        """
        if self.nivel_actual == 1:
            if self.granjero.codigo == 3 and self.m_pala not in self.grupo_marcadores.sprites():
                self.grupo_marcadores.add(self.m_pala)
                [self.limites.remove(i) for i in self.limites.sprites() if i.id == 15]
        elif self.nivel_actual == 2:
            if self.granjero.codigo == 27 and self.m_pala not in self.grupo_marcadores.sprites():
                self.grupo_marcadores.add(self.m_pala)
                [self.limites.remove(i) for i in self.limites.sprites() if i.id == 24]
        
    def mostrar_pregunta(self):
        """
        Muestra un mensaje emergente con el enunciado correspondiente al objeto encontrado.
        En el nivel 2 este mensaje solo aparece si se ha recogido previamente la carretilla.
        """
        if not self.texto_visible:
            if self.granjero.codigo >= 0 or self.sprite.nombre == "la carretilla. ":
                r1 = random.randint(0, len(self.preguntas.nros) - 1)
                aleatorio = self.preguntas.nros[r1]
                self.leer_respuestas(self.preguntas.dic_pre[aleatorio], self.preguntas.dic_res_lector[aleatorio])
                self.preguntas.valor = aleatorio
                self.popup_pregunta = PopUp(self.parent, (self.preguntas.dic_pr[aleatorio]), "Aceptar", 0, self.grupo_popup, 1)
                self.popup_pregunta.agregar_grupo()
                self.texto_visible = True

    def detectar_colision(self):
        """
        Indica si existe una colisión entre el personaje y los objetos que se pueden recoger.
        De esta manera se determina cuando se deben mostrar los mensajes emergentes y cual sera su contenido.
        """
        if self.granjero.rt_car.collidelist(self.grupo_objetos.sprites()) != -1:
            self.sprite = self.grupo_objetos.sprites()[self.granjero.rt_car.collidelist(self.grupo_objetos.sprites())]
            self.choque = True
        else:
            self.choque = False
    
    def colision_marcador(self):
        """
        Indica si existe una colisión entre el personaje y los marcadores de posición.
        De esta manera se determina cuando se debe solicitar al sintetizador de voz que lea las instrucciones
        correspondientes.
        """
        if self.granjero.rect.collidelist(self.grupo_marcadores.sprites()) != -1:
            self.marcador = self.grupo_marcadores.sprites()[self.granjero.rect.collidelist(self.grupo_marcadores.sprites())]
            self.marker = True
        else:
            self.marker = False
    
    def animar_fondo(self):
        """
        Cada vez que la pantalla se actualiza, desplaza ligeramente la posición de la nube para simular un 
        movimiento constante en el fondo.
        """
        self.nubes.rect.move_ip(self.vel_nube, 0)
        if self.nubes.rect.left + self.nubes.rect.width + 100 < 0:
            self.nubes.mover(1024)
            
    def dibujar_rectangulos(self, lista):
        """
        Dibuja los rectángulos de una lista de objetos de la actividad. Permite al programador ubicar 
        facilmente los objetos en la pantalla. 
        @param lista: Una lista de objetos que tengan al menos el atributo rect.
        @type lista: list
        """
        for i in lista:
            pygame.draw.rect(self.visor, (255, 0, 0), i, 1)

    def draw(self):
        """
        Dibuja el fondo de pantalla y los elementos pertenecientes a los grupos de sprites sobre la superficie 
        del manejador de pantallas.
        """
        self.animar_fondo()
        self.raton.update()
        self.visor.blit(self.fondo, (0, 0))
        self.anim_fondo.draw(self.visor)
        self.grupo_imagenes.draw(self.visor)
        self.grupo_objetos.draw(self.visor)
        self.grupo_botones.draw(self.visor)
        self.grupo_personaje.draw(self.visor)
        #self.dibujar_rectangulos(self.grupo_marcadores.sprites())
        #self.dibujar_rectangulos(self.limites.sprites())
        #pygame.draw.rect(self.visor, (255, 0, 0), self.granjero.rt_car, 1)
        #pygame.draw.rect(self.visor, (255, 0, 0), self.granjero.rect, 1)
        #pygame.draw.rect(self.visor, (255, 0, 0), self.meta, 1)
        self.grupo_popup.draw(self.visor)
    
    def start(self):
        pass
    
    def cleanUp(self):
        pass
Exemple #2
0
class estado(pantalla.Pantalla):
    def __init__(self, parent, previa = False):
        """
        Método inicializador de la clase. 
        
        @param parent: Instancia del gestor de pantallas.
        @type parent: Manejador
        @param previa: Si es True indica que esta pantalla esta apilada sobre otra. Si es False indica que esta
        pantalla fue cargada a través del método changeState del Manejador.
        @type previa: bool
        """
        self.parent = parent
        self.previa = previa
        self.fondo_acc = pygame.image.load(self.fondos + "fondo-acc-visual.png").convert()
        self.background = self.fondo_acc
        self.banner_inf = imagen(self.banners + "banner-inf.png", 0, 432)
        self.banner_acc_visual = imagen(self.banners + "banner-acc-visual.png", 0, 0)
        self.puerta = boton("puerta", "Regresar", self.botones + "boton-puerta.png", 3, 60, 425, None, False, 1)
        self.guardar = boton("guardar", "Guardar", self.botones + "boton-guardar.png", 3, 860, 445, None, False, 1)
        
        # Botones magnificador
        self.img1 = pygame.image.load(self.pops + "f5.png").convert_alpha()
        self.img2 = pygame.image.load(self.pops + "mas.png").convert_alpha()
        self.img3 = pygame.image.load(self.pops + "menos.png").convert_alpha()
        cont_img = {"F5": self.img1, "MAS": self.img2, "MENOS": self.img3}
        self.onmag = boton("onmag", "none", self.botones + "cuadro.png", 1, 130, 120, None, False, 1)
        self.onmag_si = boton("onmag-si", "none", self.botones + "cuadro-1.png", 1, 130, 120, None, False, 1)
        self.offmag = boton("offmag", "none", self.botones + "cuadro.png", 1, 245, 120, None, False, 1)
        self.offmag_si = boton("offmag-si", "none", self.botones + "cuadro-1.png", 1, 245, 120, None, False, 1)
        self.popup_mag = PopUp(parent, p1_vis["texto_mag"], "", cont_img , self.grupo_popup, 2, 730, 230, -50)
        
        # Botones tamaño de letra
        self.tam18 = boton("18", "none", self.botones + "cuadro.png", 1, 130, 200, None, False, 1)
        self.tam18_sel = boton("18-si", "none", self.botones + "cuadro-1.png", 1, 130, 200, None, False, 1)
        self.tam20 = boton("20", "none", self.botones + "cuadro.png", 1, 210, 200, None, False, 1)
        self.tam20_sel = boton("20-si", "none", self.botones + "cuadro-1.png", 1, 210, 200, None, False, 1)
        self.tam22 = boton("22", "none", self.botones + "cuadro.png", 1, 290, 200, None, False, 1)
        self.tam22_sel = boton("22-si", "none", self.botones + "cuadro-1.png", 1, 290, 200, None, False, 1)
        
        # Botones Sintetizador de voz
        self.lector = boton("lector", "none", self.botones + "cuadro.png", 1, 130, 295, None, False, 1)
        self.lector_si =boton("lector-si", "none", self.botones + "cuadro-1.png", 1, 130, 295, None, False, 1)
        self.oflector = boton("oflector", "none", self.botones + "cuadro.png", 1, 245, 295, None, False, 1)
        self.oflector_si = boton("oflector-si", "none", self.botones + "cuadro-1.png", 1, 245, 295, None, False, 1)
        
        # Botones audio
        self.vbaja = boton("vbaja", "none", self.botones + "cuadro.png", 1, 93, 390, None, False, 1)
        self.vbaja_sel = boton("vbaja-si", "none", self.botones + "cuadro-1.png", 1, 93, 390, None, False, 1)
        self.vmedia = boton("vmedia", "none", self.botones + "cuadro.png", 1, 208, 390, None, False, 1)
        self.vmedia_sel = boton("vmedia-si", "none", self.botones + "cuadro-1.png", 1, 208, 390, None, False, 1)
        self.vrapida = boton("vrapida", "none", self.botones + "cuadro.png", 1, 332, 390, None, False, 1)
        self.vrapida_sel = boton("vrapida-si", "none", self.botones + "cuadro-1.png", 1, 332, 390, None, False, 1)
        
        # Configuracion accesibilidad visual textos
        self.acc3_1 = texto(10, 70, u"1.- ¿Te gustaría hacer el recorrido con un Magnificador de Pantalla? ", 20, "normal", 400)
        self.acc3_2 = texto(100, 120, u"Sí             No ", 20, "normal", 500)
        self.acc3_3 = texto(10, 250, u"3.- ¿Deseas activar el lector de pantalla? ", 20, "normal", 400)
        self.acc3_4 = texto(100, 300, u"Sí             No ", 20, "normal", 500)
        self.acc3_5 = texto(10, 340, u"4.- Elije la velocidad del lector de pantalla. ", 20, "normal", 400)
        self.acc3_6 = texto(40, 390, u"Lenta         Media         Rápida ", 20, "normal", 500)
        self.acc3_7 = texto(200, 400, u"Pulsa sobre el botón guardar para salvar tu configuración. ", 20, "normal", 500)
        self.acc3_8 = texto(10, 160, u"2.- Elige el tamaño de la letra. ", 20,"normal", 400)
        self.acc3_9 = texto(100, 200, u"18         20        22 ", 20, "normal", 400)
        instrucciones = u"Pantalla: Discapacidad visual: Instrucciones: pulsa las teclas uno, 2, o 3, para seleccionar la opcion de tu preferencia, en cada una de las siguientes preguntas, o pulsa la tecla escape para volver al menú: "
        self.pregunta1 = u"¿Deseas activar el lector de pantalla? Si deseas activarlo presiona uno. Si no deseas activarlo pulsa 2. "
        self.pregunta2 = u"Elige la velocidad del lector de pantalla: Si deseas velocidad lenta, pulsa uno. Velocidad media, pulsa 2. Velocidad rápida, pulsa 3."
        self.cargar_preferencias()
        self.spserver.stopserver()
        self.opcion = 1
        self.spserver.processtext(instrucciones + self.pregunta1, True)
        
    def start(self):
        pass
 
    def cleanUp(self):
        pass
 
    def pause(self):
        pass
 
    def resume(self):
        pass

    def cargar_preferencias(self):    
        """
        Si existe una configuración anterior, cargara los elementos en el mismo orden y posición,
        de lo contrario cargara la posición y valor por defecto de los elementos de la pantalla.
        """                                          
        self.grupo_palabras.add(self.acc3_1.img_palabras, self.acc3_2.img_palabras, self.acc3_3.img_palabras, self.acc3_4.img_palabras, self.acc3_8.img_palabras, self.acc3_9.img_palabras)
        self.grupo_banner.add(self.banner_acc_visual, self.banner_inf)
        self.parent.config.consultar()
        if self.parent.config.cache == True:
            self.grupo_botones.add(self.puerta)
            if self.parent.config.magnificador:
                self.grupo_botones.add(self.onmag_si, self.offmag)
                self.popup_mag.agregar_grupo()
            else:
                self.grupo_botones.add(self.onmag, self.offmag_si)                                 
                self.popup_mag.eliminar_grupo()
                
            if self.parent.config.t_fuente == 18:
                self.grupo_botones.add(self.tam18_sel, self.tam20, self.tam22)
            elif self.parent.config.t_fuente == 20:
                self.grupo_botones.add(self.tam18, self.tam20_sel, self.tam22)
            elif self.parent.config.t_fuente == 22:
                self.grupo_botones.add(self.tam18, self.tam20, self.tam22_sel)
            
            if self.parent.config.activar_lector == True:
                self.grupo_botones.add(self.lector_si, self.oflector)
                self.grupo_palabras.add(self.acc3_5.img_palabras, self.acc3_6.img_palabras)
                if self.parent.config.synvel == "baja":
                    self.grupo_botones.add(self.vbaja_sel, self.vmedia, self.vrapida)
                elif self.parent.config.synvel == "media":
                    self.grupo_botones.add(self.vbaja, self.vmedia_sel, self.vrapida)
                elif self.parent.config.synvel == "rapida":
                    self.grupo_botones.add(self.vbaja, self.vmedia, self.vrapida_sel)
            else:
                self.grupo_botones.add(self.lector, self.oflector_si)
                self.grupo_palabras.remove(self.acc3_5.img_palabras, self.acc3_6.img_palabras)
        else:
            self.grupo_botones.add(self.puerta, self.onmag, self.offmag_si, self.tam18_sel, self.tam20, self.tam22, self.lector, self.oflector_si )
    
    def manejador_preguntas(self, tecla):
        """
        Determina que instrucción leerá el sintetizador de pantalla mientras el usuario configura esta pantalla. 
        """
        if self.opcion == 1:
            if tecla == 1:
                self.spserver.stopserver()
                self.grupo_botones.remove(self.lector, self.oflector_si, self.guardar)
                self.grupo_botones.add(self.lector_si, self.oflector, self.vbaja_sel, self.vmedia, self.vrapida, self.guardar)
                self.grupo_palabras.add(self.acc3_5.img_palabras, self.acc3_6.img_palabras)                       
                self.parent.config.activar_lector = True
                self.spserver.processtext(self.pregunta2, True)
                self.opcion += 1
                
            elif tecla == 2:
                self.opcion = 3
                self.grupo_botones.remove(self.lector_si, self.oflector, self.vbaja, self.vbaja_sel, self.vmedia, self.vmedia_sel, self.vrapida, self.vrapida_sel, self.guardar)
                self.grupo_palabras.remove(self.acc3_5.img_palabras, self.acc3_6.img_palabras)
                self.grupo_botones.add(self.lector, self.oflector_si, self.guardar)
                self.parent.config.activar_lector = False
                self.spserver.processtext(u"Has configurado el lector de pantalla exitosamente, presiona enter para continuar. ", True)
                
        elif self.opcion == 2:
            if tecla == 1:
                self.grupo_botones.remove(self.vbaja, self.vmedia_sel, self.vrapida, self.vrapida_sel, self.guardar)
                self.grupo_botones.add(self.vbaja_sel, self.vmedia, self.vrapida, self.guardar)
                self.parent.config.synvel = "baja"
                
            elif tecla == 2:
                self.grupo_botones.remove(self.vbaja, self.vbaja_sel, self.vmedia, self.vrapida, self.vrapida_sel, self.guardar)
                self.grupo_botones.add(self.vbaja, self.vmedia_sel, self.vrapida, self.guardar)
                self.parent.config.synvel = "media"
                                
            elif tecla == 3:
                self.grupo_botones.remove(self.vbaja, self.vbaja_sel, self.vmedia, self.vmedia_sel, self.vrapida, self.guardar)
                self.grupo_botones.add(self.vbaja, self.vmedia, self.vrapida_sel, self.guardar)
                self.parent.config.synvel = "rapida"
            self.opcion += 1
            self.spserver.processtext(u"Has configurado el lector de pantalla exitosamente, presiona enter para continuar.", True)
                
        elif self.opcion == 3:
            if tecla ==4:
                self.parent.config.cache = True
                if self.parent.config.t_fuente != self.parent.config.preferencias["t_fuente"]:
                    self.parent.config.texto_cambio = True
                self.parent.config.guardar_preferencias()
                self.spserver.actualizar_servidor()
                self.limpiar_grupos()
                if self.parent.primera_vez:
                    self.parent.changeState(pantalla2.estado(self.parent))
                else:
                    if self.previa:
                        self.parent.VOLVER_PANTALLA_PREVIA = True
                    self.parent.popState()
    
    def handleEvents(self, events):
        """
        Evalúa los eventos que se generan en esta pantalla.        

        @param events: Lista de los eventos.
        @type events: list
        """ 
        for event in events:
            if event.type == pygame.QUIT:
                self.parent.quit()
                
            if event.type == pygame.KEYDOWN :
                if event.key == pygame.K_ESCAPE:
                    self.limpiar_grupos()
                    self.parent.config.consultar()
                    if self.previa:
                        self.parent.VOLVER_PANTALLA_PREVIA = True
                    self.parent.popState()  
                elif event.key == 49:            
                    self.manejador_preguntas(1)
                elif event.key == 50:
                    self.manejador_preguntas(2)
                elif event.key == 51:
                    self.manejador_preguntas(3)                    
                elif event.key == pygame.K_RETURN:
                    self.manejador_preguntas(4)
            
            if pygame.sprite.spritecollideany(self.raton, self.grupo_botones):
                sprite = pygame.sprite.spritecollide(self.raton, self.grupo_botones, False)
                if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
                                
                    if sprite[0].id == "puerta":
                        self.limpiar_grupos()
                        self.parent.config.consultar()
                        self.parent.popState()
                                     
                    elif sprite[0].id == "18":
                        self.grupo_botones.remove(self.tam18, self.tam20_sel, self.tam22_sel)
                        self.grupo_botones.add(self.tam18_sel, self.tam20, self.tam22, self.guardar)
                        self.parent.config.t_fuente = 18
                                
                    elif sprite[0].id == "20":
                        self.grupo_botones.remove(self.tam18_sel, self.tam20, self.tam22_sel)
                        self.grupo_botones.add(self.tam18, self.tam20_sel, self.tam22, self.guardar)
                        self.parent.config.t_fuente = 20
                            
                    elif sprite[0].id == "22":    
                        self.grupo_botones.remove(self.tam18_sel, self.tam20_sel, self.tam22)
                        self.grupo_botones.add(self.tam18, self.tam20, self.tam22_sel, self.guardar)
                        self.parent.config.t_fuente = 22
                                           
                    elif sprite[0].id == "onmag":
                        self.grupo_botones.remove(self.onmag, self.offmag_si)
                        self.grupo_botones.add(self.onmag_si, self.offmag, self.guardar)
                        self.popup_mag.agregar_grupo()
                        self.parent.config.magnificador = True
                        
                    elif sprite[0].id == "offmag":
                        self.grupo_botones.remove(self.onmag_si, self.offmag)
                        self.grupo_botones.add(self.onmag, self.offmag_si, self.guardar)
                        self.popup_mag.eliminar_grupo()
                        self.parent.config.magnificador = False
                        
                    elif sprite[0].id == "oflector":
                        self.grupo_botones.remove(self.lector_si, self.oflector, self.vbaja, self.vbaja_sel, self.vmedia, self.vmedia_sel, self.vrapida, self.vrapida_sel, self.guardar)
                        self.grupo_palabras.remove(self.acc3_5.img_palabras, self.acc3_6.img_palabras)
                        if self.parent.config.synvel != self.parent.config.preferencias["synvel"]:
                            self.parent.config.synvel = self.parent.config.preferencias["synvel"]
                        self.grupo_botones.add(self.lector, self.oflector_si, self.guardar)
                        self.parent.config.activar_lector = False
                        
                    elif sprite[0].id == "lector":
                        self.grupo_botones.remove(self.lector, self.oflector_si, self.guardar)
                        if self.parent.config.synvel == "baja":
                            self.grupo_botones.add(self.lector_si, self.oflector, self.vbaja_sel, self.vmedia, self.vrapida, self.guardar)
                        elif self.parent.config.synvel == "media":
                            self.grupo_botones.add(self.lector_si, self.oflector, self.vbaja, self.vmedia_sel, self.vrapida, self.guardar)
                        elif self.parent.config.synvel == "rapida":
                            self.grupo_botones.add(self.lector_si, self.oflector, self.vbaja, self.vmedia, self.vrapida_sel, self.guardar)
                        self.grupo_palabras.add(self.acc3_5.img_palabras, self.acc3_6.img_palabras)                       
                        self.parent.config.activar_lector = True
                        
                    elif sprite[0].id == "vbaja":
                        self.grupo_botones.remove(self.vbaja, self.vmedia_sel, self.vrapida, self.vrapida_sel, self.guardar)
                        self.grupo_botones.add(self.vbaja_sel, self.vmedia, self.vrapida, self.guardar)
                        self.parent.config.synvel = "baja"
                            
                    elif sprite[0].id == "vmedia":
                        self.grupo_botones.remove(self.vbaja, self.vbaja_sel, self.vmedia, self.vrapida, self.vrapida_sel, self.guardar)
                        self.grupo_botones.add(self.vbaja, self.vmedia_sel, self.vrapida, self.guardar)
                        self.parent.config.synvel = "media"
                             
                    elif sprite[0].id == "vrapida":
                        self.grupo_botones.remove(self.vbaja, self.vbaja_sel, self.vmedia, self.vmedia_sel, self.vrapida, self.guardar)
                        self.grupo_botones.add(self.vbaja, self.vmedia, self.vrapida_sel, self.guardar)
                        self.parent.config.synvel = "rapida"
                                                                           
                    elif sprite[0].id == "guardar":
                        self.spserver.stopserver()
                        self.parent.config.cache = True
                        if self.parent.config.t_fuente != self.parent.config.preferencias["t_fuente"]:
                            self.parent.config.texto_cambio = True
                        self.parent.config.guardar_preferencias()
                        self.spserver.actualizar_servidor()
                        self.limpiar_grupos()
                        if self.parent.primera_vez:
                            self.parent.changeState(pantalla2.estado(self.parent))
                        else:
                            if self.previa:
                                self.parent.VOLVER_PANTALLA_PREVIA = True
                            self.parent.popState()
                            
    def update(self):
        """
        Actualiza la posición del cursor, el magnificador de pantalla en caso de que este activado y los
        tooltip de los botones.
        """
        self.raton.update()
        self.obj_magno.magnificar(self.parent.screen)
        self.grupo_botones.update(self.grupo_tooltip)
        
    def draw(self):
        """
        Dibuja el fondo de pantalla y los elementos pertenecientes a los grupos de sprites sobre la superficie 
        del manejador de pantallas.
        """
        self.parent.screen.blit(self.background, (0, 0))
        self.grupo_anim.draw(self.parent.screen)
        self.grupo_banner.draw(self.parent.screen)
        self.grupo_botones.draw(self.parent.screen)
        self.grupo_palabras.draw(self.parent.screen)
        self.grupo_popup.draw(self.parent.screen)
        self.grupo_tooltip.draw(self.parent.screen)
        self.dibujar_rect()
Exemple #3
0
class actividad(pantalla.Pantalla):
    def __init__(self, parent):
        """
        Método inicializador de la clase.
        @param parent: Instancia del gestor de pantallas.
        @type parent: Manejador
        """
        self.parent = parent
        self.screen = self.parent.screen          
        self.grupo_texto= pygame.sprite.Group()   
        self.grupo_sprite = pygame.sprite.Group()         
        self.menu2 = pygame.image.load(self.varios + "fondoact3.png").convert()
        self.menu3 = self.menu2.subsurface((666, 0, 358, 572))
        self.fondo = pygame.image.load(self.varios + "fondoact3.png").convert()    
        self.teclado = 0
        self.boton = Button("boton", self.parent, "Comprobar")
        self.grupo_boton = pygame.sprite.Group()
        self.grupo_boton.add(self.boton)
        self.img1 = pygame.image.load(self.pops + "enter.png")
        img2 = pygame.image.load(self.pops + "tab.png")
        img3 = pygame.image.load(self.pops + "f1.png")
        img4 = pygame.image.load(self.pops + "esc.png")
        img5 = pygame.image.load(self.pops + "f2.png")
        self.popupbien = PopUp(self.parent ,("prueba",), "Aceptar" ,  self.img1 ,self.grupo_popup)
        self.popupnobien = PopUp(self.parent ,("prueba",), "Aceptar" ,  self.img1 ,self.grupo_popup)        
        self.instruccion1 = u"    Pulsa la tecla F1 para ver las instrucciones. "
        self.texto =  u"    Instrucciones: resuelve los siguientes problemas y verifica la respuesta colocándola en el recuadro. "\
        u"La tecla F2 activa o desactiva la ayuda. "\
        u"ESCAPE te permitirá regresar al menú. "\
        u"Pulsa la tecla F1 para iniciar la actividad. "
        self.imagen_aplaudiendo = pygame.image.load(self.pops + "aplaudiendo.png").convert_alpha() 
        self.imagen_pensando = pygame.image.load(self.pops + "pensando.png").convert_alpha() 
        self.imagen_vacio = pygame.image.load (self.varios + "cuadro-texto-popup.png").convert_alpha()
        self.germinador = pygame.image.load(self.pops + "germinador.png").convert_alpha()
        self.dic = {"ENTER": self.img1, u"TABULACIÓN": img2, "F1": img3, "ESCAPE": img4, "F2": img5}
        self.popup_instruccion_fija = PopUp(self.parent ,self.instruccion1, "Aceptar" ,  self.dic ,self.grupo_popup,2,845,90+self.parent.config.t_fuente,-280)
        self.popupayuda = PopUp(self.parent ,self.texto, "Aceptar" ,  self.dic ,self.grupo_popup,2,512,281,100)
        self.texto_ayuda = u"    Calcula el número total de flores que puedes armar en paquetes de 25 flores. "
        self.popupvacio = PopUp(self.parent ,(self.instruccion1,), "Aceptar" ,  self.img1 ,self.grupo_popup)
        self.popupinstruccion =  PopUp(self.parent ,self.texto_ayuda, "Aceptar" ,  self.dic ,self.grupo_popup,2,512,281)  
        self.popup_instruccion_fija.agregar_grupo()
        self.popupayuda.agregar_grupo()
        self.marcador_instruccion = 0
        self.nivel1()
        self.nivel_cargado = 0
    
    def nivel1(self):
        """
        Carga las imágenes e inicializa los objetos del nivel 1 de la actividad número 2.
        """
        self.nivel = 1
        self.boton_x = pygame.sprite.Sprite()
        self.boton_x.image = pygame.image.load(self.varios + "cerrar.png").convert_alpha()
        self.boton_x.rect = (self.boton_x.image.get_rect())    
        self.boton_x.rect.move_ip(610,11)            
        self.boton_mesa = pygame.sprite.Sprite()
        self.boton_mesa.image = pygame.image.load(self.varios + "mesa.png").convert_alpha()
        self.boton_mesa.rect = ((0,415),self.boton_mesa.image.get_size())            
        self.boton_ayuda= pygame.sprite.Sprite()
        self.boton_ayuda.image = pygame.image.load(self.varios + "ayuda.png").convert_alpha()
        self.boton_ayuda.rect = (self.boton_ayuda.image.get_rect())
        self.boton_ayuda.rect.move_ip(985,500)            
        self.rectangulo_texto = pygame.sprite.Sprite()
        self.rectangulo_texto.image = pygame.image.load(self.varios + "cuadro-texto.png").convert()
        self.rectangulo_texto.rect = self.rectangulo_texto.image.get_rect()
        self.grupo_sprite.add(self.boton_ayuda,self.boton_x,self.rectangulo_texto,self.boton_mesa)
        animacion1 = animacion("anim1", self.varios+"reloj.png",5,1,446,38,None,True,100)
        animacion2 = animacion("anim2",self.varios+"obreros.png",6,1,-76,-39, None,True,6)
        animacion3 = animacion("anim3", self.varios+"caja.png",8, 1,520,355, None,True,36)
        self.grupo_anim.add(animacion1,animacion2,animacion3)
        self.pregunta = u"    Los trabajadores de una floristería tienen que empacar 3.215 flores en paquetes de 25 flores cada uno. "\
        u"¿Cuántas flores sobran después de armar todos los paquetes? "
        self.pregunta_l = u"    Los trabajadores de una floristería tienen que empacar 3215 flores en paquetes de 25 flores cada uno. "\
        u"¿Cuántas flores sobran después de armar todos los paquetes? "
        texto = texto2(700, self.popup_instruccion_fija.tam, self.pregunta, self.parent.config.t_fuente , "normal", 985,0)            
        self.grupo_texto.add(texto.img_palabras)
        self.rectangulo_texto.rect.move_ip(725,self.popup_instruccion_fija.tam + texto.ancho_final + self.parent.config.t_fuente-5)
        self.intr_texto= cajatexto(730,self.popup_instruccion_fija.tam + texto.ancho_final + self.parent.config.t_fuente, "15" , self.screen,"medium")
        self.boton.mover_boton(666+(self.menu3.get_rect().w/2), self.popup_instruccion_fija.tam + texto.ancho_final +80)
        self.texto_bien = u"    ¡Muy bien! Sabías que... un trozo de tallo verde que sea introducido en la tierra para multiplicar una planta tiene por nombre esqueje. "
        self.texto_mal = u"    Recuerda: si se reparte de forma equitativa las flores, podrás saber cuantas cajas lograrás armar. "
        self.texto_vacio = u"    Para continuar deberás contestar correctamente la pregunta. Si la casilla queda vacía no podrás avanzar al siguiente problema. "
        self.texto_ayuda = u"    Calcula el número total de flores que puedes armar en paquetes de 25 flores. "
        self.spserver.processtext(self.texto , self.parent.config.activar_lector)   
        if self.teclado == 0:
            self.teclado = True     

    def nivel2(self):
        """
        Carga las imágenes e inicializa los objetos del nivel 2 de la actividad número 2.
        """
        pygame.event.clear
        self.nivel = 2
        self.grupo_sprite.remove(self.boton_mesa)
        self.grupo_texto.empty()
        self.grupo_anim.empty()
        animacion1 = animacion("anim0_1", self.varios + "animacion4.png",10,1,-40,0,None,True,25)
        self.grupo_anim.add(animacion1)
        self.fondo = pygame.image.load(self.varios+"fondoact4.png").convert()
        self.pregunta = u"    En una cesta hay 60 sobres de semillas, de ellos 1/5 son de pimentón, 1/2 son de girasol y el resto de perejil. ¿Cuántos sobres son de semillas de perejil? "
        texto = texto2(700, self.popup_instruccion_fija.tam, self.pregunta, self.parent.config.t_fuente, "normal", 985)
        self.grupo_texto.add(texto.img_palabras)
        self.pregunta_lector = u"    En una cesta hay 60 sobres de semillas, de ellos un quinto son de pimentón, un medio son de girasol y el resto de perejil. ¿Cuántos sobres son de semilla de perejil? "
        self.rectangulo_texto.rect.y =self.popup_instruccion_fija.tam + texto.ancho_final + self.parent.config.t_fuente-5
        self.intr_texto= cajatexto(730,self.popup_instruccion_fija.tam + texto.ancho_final + self.parent.config.t_fuente, "18" , self.screen,"medium")
        self.boton.mover_boton(666+(self.menu3.get_rect().w/2), self.popup_instruccion_fija.tam + texto.ancho_final +80)        
        self.texto_bien = u"    ¡Excelente! Para evitar la deforestación y contribuir con el cuidado del ambiente, cuando vayas de visita a los parques recoge los desechos que te hayan quedado durante tu visita. "
        self.texto_mal = u"    Recuerda: un sobre esta representado en fracciones como 1/60. "
        self.texto_mal_lector = u"    Recuerda: un sobre está representado en fracciones como 1 entre 60. "
        self.texto_vacio = u"    Para continuar deberás contestar correctamente la pregunta. Si la casilla queda vacía no podrás avanzar al siguiente problema. "
        self.texto_ayuda = u"    Al construir la ecuación utiliza los 60 sobres como la unidad. Luego de hallar el valor en fracciones transformala a números naturales. "
        self.nivel_cargado = 1
        self.spserver.processtext(u"problema número 2:"+self.pregunta_lector  + u"escribe tu respuesta y utiliza la tecla ENTER para confirmar" , self.parent.config.activar_lector)
        if self.teclado == 0:
            self.teclado = True        
        
    def nivel3 (self):
        """
        Carga las imágenes e inicializa los objetos del nivel 3 de la actividad número 2.
        """
        pygame.event.clear
        self.nivel=3        
        self.grupo_texto.empty()
        self.grupo_anim.empty()           
        self.grupo_anim.empty()
        self.fondo = pygame.image.load(self.varios+"fondoact5.png").convert()
        animacion1 = animacion("anim_1", self.varios+"animacion5.png",6,1,-30,44,None,True,25)
        self.grupo_anim.add(animacion1)
        self.pregunta =u"  Una distribuidora de flores recibió 12.831 bolívares por concepto de las ventas durante el mes de marzo. Si vendieron 987 flores, ¿Cuál es el costo de cada flor? "
        self.pregunta_l =u"  Una distribuidora de flores recibió 12831 bolívares por concepto de las ventas durante el mes de marzo. Si vendieron 987 flores, ¿Cuál es el costo de cada flor? "
        texto = texto2(700, self.popup_instruccion_fija.tam, self.pregunta, self.parent.config.t_fuente, "normal", 985)
        self.grupo_texto.add(texto.img_palabras)
        self.rectangulo_texto.rect.y =self.popup_instruccion_fija.tam + texto.ancho_final + self.parent.config.t_fuente-5
        self.intr_texto= cajatexto(730,self.popup_instruccion_fija.tam + texto.ancho_final + self.parent.config.t_fuente, "13" , self.screen,"medium")
        self.boton.mover_boton(666 +(self.menu3.get_rect().w/2), self.popup_instruccion_fija.tam + texto.ancho_final +80)        
        self.texto_bien = u"   ¡Muy bien! ¿Has hecho alguna vez un germinador con semillas de caraota? Con la ayuda de tu maestra o maestro investiga los pasos a seguir para que una semilla se reproduzca y se logre obtener una nueva planta. "
        self.texto_mal = u"    Recuerda: debes separar en partes iguales para obtener el valor de cada flor. "
        self.texto_vacio = u"    Para continuar deberás contestar correctamente la pregunta. Si la casilla queda vacía no podrás avanzar al siguiente problema. "
        self.texto_ayuda = u"    Existe una operación básica que te permite repartir equitativamente una cantidad entre un cierto número. Es el proceso contrario a la multiplicación. "
        self.spserver.processtext(u"problema número 3:"+self.pregunta + u"escribe tu respuesta y utiliza la tecla ENTER para confirmar", self.parent.config.activar_lector)   
        if self.teclado == 0:
            self.teclado = True     
                  
    def click(self, event):
        """
        Verifica cuando se hizo click.

        @param event: Evento que notifica si se hizo click.
        @type event: pygame.event.Event

        @return: True si se realizo el click, sino retorna False.
        @rtype: bool
        """
        if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
            if pygame.mouse.get_pressed()[0]:
                return True
            else:
                return False
    
    def manejador_popups(self, tipo_mensaje):
        """
        Evalúa el tipo de mensaje que se dibujara en la ventana emergente.
        @param tipo_mensaje: Define el tipo de mensaje que se mostrará. Acepta los siguientes valores:
        "bien", "mal", "vacio", "instruccion".
        @type tipo_mensaje: str
        """
        if not self.popupnobien.activo or not self.popupbien.activo:
            if tipo_mensaje == "bien":
                self.spserver.stopserver()  
                if self.nivel ==3:
                    self.spserver.processtext(self.texto_bien+u"Terminaste todos los problemas! Pulsa enter para volver al menú del recurso.", self.parent.config.activar_lector)           
                    self.popupbien = PopUp(self.parent ,(self.texto_bien,), "Aceptar" ,  (self.germinador,self.imagen_aplaudiendo) ,self.grupo_popup)

                else:
                    self.spserver.processtext(self.texto_bien+u"Pulsa enter para pasar al siguiente problema. ", self.parent.config.activar_lector)
                    self.popupbien = PopUp(self.parent ,(self.texto_bien,), "Aceptar" ,  self.imagen_aplaudiendo ,self.grupo_popup)
                                
                self.popupbien.agregar_grupo()
                                
            
            elif tipo_mensaje == "mal":
                self.popupnobien = PopUp(self.parent ,(self.texto_mal,), "Aceptar" ,  self.imagen_pensando ,self.grupo_popup)
                self.popupnobien.agregar_grupo() 
                self.spserver.stopserver()
                if self.nivel ==2:
                    self.spserver.processtext(u"tu respuesta es: "+ self.intr_texto.palabra_f + self.texto_mal_lector + u"Pulsa enter para continuar", self.parent.config.activar_lector)
                    self.intr_texto.reiniciar()
                else:
                    self.spserver.processtext(u"tu respuesta es: "+ self.intr_texto.palabra_f +self.texto_mal+u" Pulsa enter para continuar", self.parent.config.activar_lector)
                    self.intr_texto.reiniciar()
                
            elif tipo_mensaje == "vacio":
                self.popupvacio = PopUp(self.parent ,(self.texto_vacio,), "Aceptar" ,  self.imagen_vacio,self.grupo_popup)
                self.popupvacio .agregar_grupo()            
                self.spserver.stopserver()
                self.spserver.processtext(self.texto_vacio+u"Pulsa enter para continuar", self.parent.config.activar_lector)                                       
                
            elif tipo_mensaje == "instruccion":
                if self.popupinstruccion.activo:
                    
                    self.spserver.stopserver()
                    self.popupinstruccion.eliminar_grupo()
                    if self.nivel==2:   
                        self.spserver.processtext(self.pregunta_lector + u"escribe tu respuesta y utiliza la tecla ENTER para confirmar", self.parent.config.activar_lector)                                       
                    else:                                       
                        self.spserver.processtext(self.pregunta_l + u"escribe tu respuesta y utiliza la tecla ENTER para confirmar", self.parent.config.activar_lector)
                                                   
                else: 
                    self.popupinstruccion =  PopUp(self.parent ,self.texto_ayuda, "Aceptar" ,  self.dic ,self.grupo_popup,2,512,281)   
                    self.popupinstruccion.agregar_grupo()
                    self.spserver.stopserver()
                    self.spserver.processtext(self.texto_ayuda + u"Pulsa F2 para continuar.", self.parent.config.activar_lector)                                       
    
    def evaluador(self):
        """
        Evalúa si es correcto el contenido de la caja de texto y llama al método manejador_popups(). 
        """
        if self.intr_texto.comparador():
            self.manejador_popups("bien")

        elif self.intr_texto.caja_vacia():
            self.manejador_popups("vacio")

        elif not self.intr_texto.comparador():
            self.manejador_popups("mal")

    def update(self):
        """"
        Actualiza los grupos de sprites y la pantalla.
        """ 
        grupo_cuadro_texto = pygame.sprite.Group()
        self.intr_texto.titilar()
        self.intr_texto.get_imagen(grupo_cuadro_texto)
        self.screen.blit(self.fondo,(0,0))
        self.grupo_anim.draw(self.screen)          
        self.parent.screen.blit (self.menu3 ,(666,0))            
        self.grupo_sprite.draw(self.screen)          
        self.grupo_texto.draw(self.screen)
        self.grupo_boton.draw(self.screen)
        grupo_cuadro_texto.draw(self.screen)
        self.grupo_popup.draw(self.screen)    

    def handleEvents(self, eventos):         
        """
        Evalúa los eventos que se generan en esta pantalla.        
        @param eventos: Lista de los eventos.
        @type eventos: list
        """
        teclasPulsadas = pygame.key.get_pressed()
        for event in eventos:
            if (event.type == pygame.QUIT):
                self.parent.quit()                

            if not self.popupbien.activo and not self.popupnobien.activo and not self.popupvacio.activo:
                
                if self.teclado == 0:
                    self.teclado = True
            if self.popupbien.activo:
                self.popupbien.manejador_eventos(event)
                if not self.popupbien.evaluar_click():
                    self.spserver.stopserver()
                    if self.nivel == 1:
                        self.nivel2()
                    elif self.nivel == 2:
                        self.nivel3()
                    elif self.nivel == 3:
                        self.limpiar_grupos()
                        self.parent.pushState(pantalla2.estado(self.parent))                         

            if self.popupnobien.activo:
                self.popupnobien.manejador_eventos(event)               
                if not self.popupnobien.evaluar_click():
                    self.spserver.stopserver()
                    if self.nivel==2:
                        self.spserver.processtext(self.pregunta_lector+u"escribe tu respuesta y utiliza la tecla ENTER para confirmar", self.parent.config.activar_lector)
                    else:
                        self.spserver.processtext(self.pregunta_l+u"escribe tu respuesta y utiliza la tecla ENTER para confirmar", self.parent.config.activar_lector)             

            if self.popupvacio.activo:   
                self.popupvacio.manejador_eventos(event) 
                pygame.event.clear()         
                if not self.popupvacio.evaluar_click():
                    self.spserver.stopserver()   
                    if self.nivel==2:
                        self.spserver.processtext(self.pregunta_lector+u"escribe tu respuesta y utiliza la tecla ENTER para confirmar", self.parent.config.activar_lector)
                    else:
                        self.spserver.processtext(self.pregunta_l+u"escribe tu respuesta y utiliza la tecla ENTER para confirmar", self.parent.config.activar_lector)             


            if teclasPulsadas[pygame.K_ESCAPE]:
                self.limpiar_grupos()
                self.parent.pushState(pantalla2.estado(self.parent)) 

            if self.click(event):

                if not self.popupayuda.activo and not self.popupbien.activo and not self.popupnobien.activo:

                    if not self.popupinstruccion.activo:
                        if self.rectangulo_texto.rect.collidepoint(pygame.mouse.get_pos()):
                            self.teclado = True
                        else:
                            self.teclado= False

                        if self.boton.rect.collidepoint(pygame.mouse.get_pos()):
                            self.evaluador()                                                                        

                    if self.boton_ayuda.rect.collidepoint(pygame.mouse.get_pos()):                
                        self.manejador_popups("instruccion")

                if self.boton_x.rect.collidepoint(pygame.mouse.get_pos()):
                    self.limpiar_grupos()
                    self.parent.pushState(pantalla2.estado(self.parent)) 

            if event.type == pygame.KEYDOWN:  
                if teclasPulsadas[pygame.K_TAB]:
                    if not self.popupinstruccion.activo and not self.popupayuda.activo and not self.popupbien.activo and not self.popupnobien.activo:
                        if self.teclado == 0:
                            self.teclado = True

                            if self.intr_texto.caja_vacia():
                                self.spserver.stopserver()
                                self.spserver.processtext(u"escribe los números que corresponden a la respuesta correcta." , self.parent.config.activar_lector)                                                      
                            else:
                                self.spserver.stopserver()
                                self.spserver.processtext(u"has escrito el número: "+self.intr_texto.palabra_f , self.parent.config.activar_lector)                                       

                if teclasPulsadas[pygame.K_F2]:
                    if not self.popupayuda.activo and not self.popupbien.activo and not self.popupnobien.activo:
                        self.manejador_popups("instruccion")

                if teclasPulsadas [pygame.K_SPACE]:
                    self.spserver.repetir()                    

                if teclasPulsadas[pygame.K_F1]:
                    self.spserver.stopserver()
                    if self.popupayuda.activo:
                        self.popupayuda.eliminar_grupo()
                        if not self.marcador_instruccion:
                            self.spserver.stopserver()
                            self.spserver.processtext(self.pregunta_l +u"escribe tu respuesta y utiliza la tecla ENTER para confirmar", self.parent.config.activar_lector)
                            self.marcador_instruccion = 1
                        if self.popupayuda.activo:
                            self.popupayuda.eliminar_grupo()
                    else:
                        self.spserver.processtext(self.texto, self.parent.config.activar_lector)
                        self.popupayuda.agregar_grupo()

            if self.intr_texto.iniciar(event, self.teclado):
                self.evaluador()
                self.teclado = 0

    def draw(self):
        pass

    def start(self):
        pass

    def pause(self):
        pass

    def cleanUp(self):
        pass