Correcciones

1 files changed, 323 insertions, 323 deletions

diff --git a/FGR_T0502.py b/FGR_T0502.py
index 09dc9eb..9ea4b57 100644
--- a/FGR_T0502.py
+++ b/FGR_T0502.py
@@ -26,26 +26,22 @@ class FGR_T0502(gtk.Widget):
 	def __init__(self, usuario):
 		gtk.Widget.__init__(self)
 		self.usuario = usuario
-		self.nombre = "Memory"
 		self.ventana = None
+		self.nombre = "Crucigrama."
 		self.estado = False
 		self.fondo = None
 		self.reloj = None
 		self.puntos = 0
-
 		# Sprites
 		self.textos = None
 		self.botonesmenu = None
 		self.controles = None
 		self.seniales = None
-		self.senial1_select = None
-		self.senial2_select = None
-
+		self.senial_select = None
 		# sonidos
 		self.sonido_error = None
 		self.sonido_exito = None
 		self.sound_select = None
-
 		# Escalado
 		self.ventana_real = None
 		self.resolucionreal = None
@@ -110,24 +106,37 @@ class FGR_T0502(gtk.Widget):
 			pygame.display.update()
 
 	def reset(self):
-		self.puntos = 0
+		self.puntos= 0
 		self.controles.init()
-		self.seniales.init()
-
-	def toma(self, senial):
-		if not self.senial1_select:
-			self.sound_select.play()
-			self.senial1_select = senial
-			self.senial1_select.seleccionar()
-			self.verificar()
-	def deja(self, senial):
-		if not self.senial2_select:
-			self.sound_select.play()
-			self.senial2_select = senial
-			self.senial2_select.seleccionar()
+		#self.seniales.init()
+
+	def toma(self, boton):
+		if boton.ubicado: return
+		self.sound_select.play()
+		self.senial_select = boton
+		self.seniales.seleccionar(self.senial_select)
+
+	def deja(self, flecha):
+		if not self.senial_select: return
+		if self.senial_select.get_text() == flecha.nombre:
+			self.sonido_exito.play()
+			self.puntos += 10
+			self.controles.actualiza_puntos()
+			self.senial_select.marcar()
+			self.senial_select = None
+			self.seniales.marcar(flecha)
 			self.verificar()
+		else:
+			self.sonido_error.play()
+			self.controles.cronometro.cron.segundos_transcurridos += 5
+
 	def verificar(self):
-		if self.senial1_select and self.senial2_select:
+		faltan = False
+		for boton in self.seniales.botones:
+			if not boton.ubicado:
+				faltan = True
+				break
+		if not faltan:
 			self.ventana.blit(self.fondo, (0,0))
 			self.seniales.draw(self.ventana)
 			self.controles.draw(self.ventana)
@@ -135,23 +144,7 @@ class FGR_T0502(gtk.Widget):
 			pygame.display.update()
 			pygame.time.wait(1000)
 			self.ventana.blit(self.fondo, (0,0))
-			if self.senial1_select.nombre == self.senial2_select.nombre:
-				self.sonido_exito.play()
-				self.puntos += 10
-				self.controles.actualiza_puntos()
-				self.senial1_select.kill()
-				self.senial2_select.kill()
-				self.senial1_select = None
-				self.senial2_select = None
-				if not self.seniales.sprites():
-					return self.victory()
-			else:
-				self.sonido_error.play()
-				self.controles.cronometro.cron.segundos_transcurridos += 5
-				self.senial1_select.reset()
-				self.senial2_select.reset()
-				self.senial1_select = None
-				self.senial2_select = None
+			return self.victory()
 
 	def victory(self):
 		pygame.mixer.music.unpause()
@@ -164,8 +157,8 @@ class FGR_T0502(gtk.Widget):
 		self.ventana_real.blit(pygame.transform.scale(self.ventana, self.resolucionreal), (0,0))
 		pygame.display.update()
 		pygame.time.wait(1000)
-		text1= "Muy bien! Ahora formas parte de la pandilla."
-		text2= "Natalia, José y Jacinto están muy contentos, sigue con ellos adelante."
+		text1= "Muy bien, ahora saben cuáles son las partes más importantes de una bici y "
+		text2= "gracias a eso consiguieron 1 sticker más. Sigan adelante!"
 		mensaje= Mensaje(self, "Victory", text1, text2)
 		self.fondo= self.fondo1
 		self.ventana.blit(self.fondo, (0,0))
@@ -184,7 +177,7 @@ class FGR_T0502(gtk.Widget):
 
 	def game_over(self, jamcron):
 		pygame.mixer.music.unpause()
-		self.controles.update()
+		self.controles.update() # para actualizar imagen de progressbar del reloj
 		self.controles.stop()
 		self.controles.actualiza_puntos()
 		self.ventana.blit(self.fondo, (0,0))
@@ -213,43 +206,45 @@ class FGR_T0502(gtk.Widget):
 
 	# ----------- SETEOS -------------
 	def load(self):
-		pygame.event.set_blocked([JOYAXISMOTION, JOYBALLMOTION, JOYHATMOTION, JOYBUTTONUP, JOYBUTTONDOWN, KEYUP, USEREVENT])
-		pygame.event.set_allowed([MOUSEMOTION, MOUSEBUTTONUP, MOUSEBUTTONDOWN, KEYDOWN, VIDEORESIZE, VIDEOEXPOSE, QUIT, ACTIVEEVENT])
+		pygame.event.set_blocked([JOYAXISMOTION, JOYBALLMOTION, JOYHATMOTION,
+			JOYBUTTONUP, JOYBUTTONDOWN, KEYUP, USEREVENT])
+		pygame.event.set_allowed([MOUSEMOTION, MOUSEBUTTONUP, MOUSEBUTTONDOWN,
+			KEYDOWN, VIDEORESIZE, VIDEOEXPOSE, QUIT, ACTIVEEVENT])
 		pygame.mouse.set_visible(True)
-		A, B = G.RESOLUCION
+		A, B= G.RESOLUCION
 		self.ventana = pygame.Surface( (A, B), flags=HWSURFACE )
-		self.ventana_real = pygame.display.get_surface()
-		C = pygame.display.Info().current_w
-		D = pygame.display.Info().current_h
-		self.resolucionreal = (C,D)
-		self.VA = float(C)/float(A)
-		self.VH = float(D)/float(B)
-		self.fondo1, self.fondo2 = G.get_Fondos_FGR_T0502()
-		self.fondo2 = JAMG.pegar_imagenes_centradas(self.fondo2, self.fondo1.copy())
-		self.textos = Textos_Intro()
-		self.botonesmenu = ButtonsMenu(self)
+		self.ventana_real= pygame.display.get_surface()
+		C= pygame.display.Info().current_w
+		D= pygame.display.Info().current_h
+		self.resolucionreal= (C,D)
+		self.VA= float(C)/float(A)
+		self.VH= float(D)/float(B)
+		self.fondo1, self.fondo2= G.get_Fondos_FGR_T0502()
+		self.textos= Textos_Intro()
+		self.botonesmenu= ButtonsMenu(self)
 		from Globals import Controles
-		self.controles = Controles(self)
-		self.seniales = Seniales(self)
-		self.sonido_error, self.sonido_exito = G.get_Sonidos()
-		self.sound_select = JAMG.get_sound_select()
+		self.controles= Controles(self)
+		self.seniales= Seniales(self)
+		self.sonido_error, self.sonido_exito= G.get_Sonidos()
+		self.sound_select= JAMG.get_sound_select()
 		self.reloj = pygame.time.Clock()
 
 	# ----------- EVENTOS en MENU ---------------
 	def handle_event_Intro(self):
 		for event in pygame.event.get(pygame.KEYDOWN):
-			tecla = event.key
-			if tecla == pygame.K_ESCAPE:
+			tecla= event.key
+			if tecla== pygame.K_ESCAPE:
 				pygame.event.clear()
-				return self.run_dialog_intro(None)
+				#return self.run_dialog_intro(None)
+				return self.salir()
 
 	def run_Instruc(self):
-		self.fondo = G.get_instruc("502")
+		self.fondo= G.get_instruc("502")
 		self.ventana.blit(self.fondo, (0,0))
 		self.botonesmenu.draw(self.ventana)
 		self.ventana_real.blit(pygame.transform.scale(self.ventana, self.resolucionreal), (0,0))
 		pygame.display.update()
-		while self.estado == "Instruc":
+		while self.estado== "Instruc":
 			self.reloj.tick(35)
 			while gtk.events_pending():
 			    	gtk.main_iteration(False)
@@ -261,6 +256,7 @@ class FGR_T0502(gtk.Widget):
 			self.ventana_real.blit(pygame.transform.scale(self.ventana, self.resolucionreal), (0,0))
 			pygame.display.update()
 
+	'''
 	def run_dialog_intro(self, button):
 		from BiblioJAM.JAMDialog import JAMDialog
 		dialog= JAMDialog(mensaje="¿Abandonas el Juego?", funcion_ok=self.ok_intro, funcion_cancel=self.cancel_intro)
@@ -286,7 +282,6 @@ class FGR_T0502(gtk.Widget):
 			dialog.draw(self.ventana)
 			self.ventana_real.blit(pygame.transform.scale(self.ventana, self.resolucionreal), (0,0))
 			pygame.display.update()
-
 		dialog.clear(self.ventana, self.fondo)
 		self.ventana_real.blit(pygame.transform.scale(self.ventana, self.resolucionreal), (0,0))
 		pygame.display.update()
@@ -294,7 +289,7 @@ class FGR_T0502(gtk.Widget):
 	def ok_intro(self, button):
 		return self.salir(False)
 	def cancel_intro(self, button):
-		self.estado = "Intro"
+		self.estado= "Intro"'''
 	# ----------- EVENTOS en MENU ---------------
 
 	# ----------- EVENTOS en JUEGO ---------------
@@ -331,7 +326,6 @@ class FGR_T0502(gtk.Widget):
 			dialog.draw(self.ventana)
 			self.ventana_real.blit(pygame.transform.scale(self.ventana, self.resolucionreal), (0,0))
 			pygame.display.update()
-
 		if self.estado== "Intro":
 			dialog.clear(self.ventana, self.fondo)
 			self.ventana_real.blit(pygame.transform.scale(self.ventana, self.resolucionreal), (0,0))
@@ -344,315 +338,312 @@ class FGR_T0502(gtk.Widget):
 			self.controles.play()
 
 	def ok(self, button):
-		self.estado = "Intro"
+		#self.estado = "Intro"
+		self.salir()
 	def cancel(self, button):
-		self.estado = "Game"
+		self.estado= "Game"
 	# ----------- EVENTOS en JUEGO ---------------
 
-	def salir(self, valor = None):
+	def salir(self, valor= None):
 		self.estado = False
 		self.emit("run_grupo", "grupo5", self.puntos)
 
-# -------- CONTROLES ----------
-'''
-class Controles(pygame.sprite.OrderedUpdates):
-	def __init__(self, main):
-		pygame.sprite.OrderedUpdates.__init__(self)
-		self.main = main
-		self.flecha = None
-		self.titulo = None
-		self.puntaje = None
-		self.cronometro = None
-		self.progress_reloj = None
-		self.sonidos_reloj = None
-		self.user = None
-
-		self.load_sprites()
-
-	def load_sprites(self):
-		imagen = self.main.usuario['personaje']
-		self.user = JAMButton(self.main.usuario['nombre'],None)
-		self.user.set_imagen(origen = imagen, tamanio = (60,60))
-		self.user.set_colores(colorbas = (0,153,255,255),
-			colorbor = (0,153,255,255), colorcara = (0,153,255,255))
-		self.user.set_tamanios(tamanio = (80,80), grosorbor = 1, detalle = 1, espesor = 1)
-		ww, hh = self.user.get_tamanio()
-		w,h = G.RESOLUCION
-		self.user.set_posicion(punto = (w - ww - 10, 25))
-		self.user.connect(callback = None, sonido_select = None)
-		self.add(self.user)
-
-		imagen= G.get_Flecha()
-		self.flecha= JAMButton("",None)
-		self.flecha.set_imagen(origen= imagen, tamanio=(100,55))
-		self.flecha.set_colores(colorbas=JAMG.get_negro(), colorcara=JAMG.get_negro())
-		self.flecha.set_tamanios(tamanio=(0,0), grosorbor=1, detalle=1, espesor=1)
-		self.flecha.set_posicion(punto= (10,10))
-		self.flecha.connect (callback= self.main.run_dialog_game)
-		self.add(self.flecha)
-
-		x,y= self.flecha.posicion
-		w,h= self.flecha.get_tamanio()
-		x+= w
-		ancho= G.RESOLUCION[0]/2 - x
-		cartel_titulo= pygame.sprite.Sprite()
-		cartel_titulo.image= G.get_Imagen_Cartel1()
-		cartel_titulo.image= pygame.transform.scale(cartel_titulo.image.copy(), (ancho,cartel_titulo.image.get_size()[1]))
-		cartel_titulo.rect= cartel_titulo.image.get_rect()
-		cartel_titulo.rect.x= x
-		cartel_titulo.rect.y= -60
-		self.add(cartel_titulo)
-
-		self.titulo= JAMLabel(self.main.nombre)
-		self.titulo.set_text(color=JAMG.get_blanco())
-		fuente, tamanio= JAMG.get_Font_fawn()
-		self.titulo.set_font_from_file(fuente, tamanio= 40)
-		w,h= G.RESOLUCION
-		x,y= (cartel_titulo.rect.x + 50, 10)
-		self.titulo.set_posicion(punto= (x,y))
-		self.add(self.titulo)
-
-		self.puntaje= JAMLabel("%s" %(self.main.puntos))
-		self.puntaje.set_text(color=JAMG.get_blanco())
-		fuente, tamanio= JAMG.get_Font_fawn()
-		self.puntaje.set_font_from_file(fuente, tamanio= 40)
-		w,h= G.RESOLUCION
-		self.add(self.puntaje)
-
-		self.sonidos_reloj= G.get_sound_clock()
-
-		from BiblioJAM.JAMCron import JAMCron
-		self.cronometro= JAMCron()
-		x,y= (0-self.cronometro.cron.rect.w-1, 0-self.cronometro.cron.rect.h-1)
-		self.cronometro.cron.set_posicion(punto= (x,y))
-		self.cronometro.set_callback(self.main.game_over)
-		self.cronometro.set_alarma(tiempo = (1,30), duracion = 3)
-		self.add(self.cronometro)
-
-		self.progress_reloj= ProgressBar(self.main)
-		self.add(self.progress_reloj)
-
-	def actualiza_puntos(self):
-		puntos = "%s" %(self.main.puntos)
-		self.puntaje.set_text(texto= puntos)
-		x,y = self.user.get_posicion()
-		w,h = self.puntaje.get_tamanio()
-		x -= w+10
-		self.puntaje.set_posicion(punto= (x,y))
-
-	def switching_game(self, button):
-		self.main.estado= "Intro"
-		return self.main.run()
-
-	def init(self):
-		sound= self.sonidos_reloj[0]
-		self.cronometro.set_sound(sound)
-		self.cronometro.reset()
-		self.actualiza_puntos()
-		self.cronometro.play()
-	def stop(self):
-		self.cronometro.pause()
-	def play(self):
-		self.cronometro.play()
-
-class ProgressBar(pygame.sprite.Sprite):
-	def __init__(self, main):
-		pygame.sprite.Sprite.__init__(self)
-		self.main = main
-		self.acumula = 0
-		w,h = G.RESOLUCION
-		self.tamanio = (w/2-10,10)
-		self.posicion = (w/2,10)
-		rect1 = JAMG.get_Rectangulo( JAMG.get_verde1(), self.tamanio)
-		w,y = rect1.get_size()
-		a = w/6*3
-		rect2 = JAMG.get_Rectangulo( JAMG.get_amarillo1(), (a,self.tamanio[1]))
-		imagen = JAMG.pegar_imagenes_alineado_derecha(rect2, rect1)
-		a = w/6
-		rect3 = JAMG.get_Rectangulo( JAMG.get_rojo1(), (a,self.tamanio[1]))
-		self.imagen_original = JAMG.pegar_imagenes_alineado_derecha(rect3, imagen)
-		self.image = self.imagen_original.copy()
-		self.rect = self.image.get_rect()
-		self.rect.x, self.rect.y= self.posicion
-
-	def update(self):
-		tiempo = self.main.controles.cronometro.cron.segundos_final
-		transcurridos = self.main.controles.cronometro.get_tiempo_transcurrido()
-		faltan = self.main.controles.cronometro.cron.segundos_faltan
-		mitad = tiempo/2
-		cuarto = tiempo/4
-		if faltan <= mitad:
-			if faltan > cuarto:
-				if not self.main.controles.cronometro.sonido == self.main.controles.sonidos_reloj[1]:
-					self.main.controles.stop()
-					self.main.controles.cronometro.set_sound(self.main.controles.sonidos_reloj[1])
-					self.main.controles.play()
-			elif faltan <= cuarto:
-				if not self.main.controles.cronometro.sonido == self.main.controles.sonidos_reloj[2]:
-					self.main.controles.stop()
-					self.main.controles.cronometro.set_sound(self.main.controles.sonidos_reloj[2])
-					self.main.controles.play()
-		ancho, alto = self.tamanio
-		ind = float(float(ancho)/float(self.main.controles.cronometro.cron.segundos_final))
-		ancho = float(float(ancho)- float(self.main.controles.cronometro.get_tiempo_transcurrido())*ind)
-		dif = float(float(self.tamanio[0]) - float(ancho))
-		try:
-			self.image = self.imagen_original.copy().subsurface((dif,0,int(ancho), int(alto)))
-		except:
-			self.image = self.imagen_original.copy().subsurface((dif,0,0,0))
-		self.rect = self.image.get_rect()
-		x,y = self.posicion
-		x += dif
-		self.rect.x, self.rect.y= (x,y)'''
-# -------- CONTROLES ----------
-
-# -------- SEÑALES ----------
 class Seniales(pygame.sprite.OrderedUpdates):
-	# Grupo de Señales.
 	def __init__(self, main):
 		pygame.sprite.OrderedUpdates.__init__(self)
 		self.main = main
-		self.seniales1 = []
-		self.seniales2 = []
+		self.palabras = {}
+		self.botones = []
+		self.flechas = {}
+		self.matriz_letras = []
+		self.textos = []
 		self.load_sprites()
+		self.set_posicion((105, 170))
 		
 	def load_sprites(self):
 		self.empty()
-		self.seniales1 = []
-		self.seniales2 = []
-		for senial in G.get_seniales_FGR_T0502():
-			boton = Senial(senial)
+		self.botones = []
+		self.palabras = {}
+		self.flechas = {}
+		self.matriz_letras = []
+		self.textos = []
+		matriz = G.get_letras_FGR_T0502()
+		for linea in matriz:
+			fila = []
+			for letra in linea:
+				l = Letra(letra)
+				fila.append(l)
+				if bool(letra): self.add(l)
+			self.matriz_letras.append(fila)
+		# Verticales
+		chaleco = []
+		for linea in self.matriz_letras[0:7]:
+			chaleco.append(linea[0])
+		self.palabras['CHALECO'] = chaleco
+		mate = []
+		for linea in self.matriz_letras[4:]:
+			mate.append(linea[5])
+		self.palabras['MATE'] = mate
+		sri = []
+		for linea in self.matriz_letras[4:7]:
+			sri.append(linea[7])
+		self.palabras['SRI'] = sri
+		bocina = []
+		for linea in self.matriz_letras[2:]:
+			bocina.append(linea[9])
+		self.palabras['BOCINA'] = bocina
+		# Horizontales
+		self.palabras['CELULAR'] = self.matriz_letras[0][0:7]
+		self.palabras['ATRAS'] = self.matriz_letras[2][0:5]
+		self.palabras['CODERA'] = self.matriz_letras[5][0:6]
+		self.palabras['MUSICA'] = self.matriz_letras[4][5:]
+
+		for key in self.palabras.keys():
+			boton = Boton(key)
 			boton.connect(callback = self.main.toma, sonido_select = None)
-			self.seniales1.append(boton)
-			self.add(boton)
-		for senial in G.get_seniales_FGR_T0502():
-			boton = Senial(senial)
-			boton.connect(callback = self.main.deja, sonido_select = None)
-			self.seniales2.append(boton)
+			self.botones.append(boton)
 			self.add(boton)
 
-	def init(self):
-		seniales = self.seniales1
-		w,h = G.RESOLUCION
-		sep = 30
-		x, y = sep, h
-		contador = 0
-		for z in range(len(seniales)):
-			contador += 1
-			random.seed()
-			senial = random.choice(seniales)
-			y -= senial.get_tamanio()[1] + sep
-			senial.set_posicion( (x,y) )
-			seniales.remove(senial)
-			if contador == 3:
-				contador = 0
-				x += senial.get_tamanio()[0] + sep
-				y = h
-		seniales = self.seniales2
-		contador = 0
-		for z in range(len(seniales)):
-			contador += 1
-			random.seed()
-			senial = random.choice(seniales)
-			y -= senial.get_tamanio()[1] + sep
-			senial.set_posicion( (x,y) )
-			seniales.remove(senial)
-			if contador == 3:
-				contador = 0
-				x += senial.get_tamanio()[0] + sep
-				y = h
-
-class Senial(JAMButton):
-	def __init__(self, senial):
-		JAMButton.__init__(self, '',None)
-		imagen2, self.nombre = senial
-		imagen1 = os.path.join(G.IMAGENES, "FGR_T0502", "memory_logo.jpg")
-		self.set_imagen(origen = imagen1, tamanio=(175, 175))
-		self.set_tamanios(tamanio = (175, 175), grosorbor=1, detalle=1, espesor=1)
-		self.imagen1 = pygame.transform.scale(pygame.image.load(imagen1),(175, 175))
-		self.imagen2 = pygame.transform.scale(pygame.image.load(imagen2),(175, 175))
+		directorio = os.path.join(G.IMAGENES, 'flechas')
+		self.flechas['CHALECO'] = Flecha('CHALECO', os.path.join(directorio, 'v_flecha1.png'))
+		self.flechas['MATE'] = Flecha('MATE', os.path.join(directorio, 'v_flecha5.png'))
+		self.flechas['SRI'] = Flecha('SRI', os.path.join(directorio, 'v_flecha7.png'))
+		self.flechas['BOCINA'] = Flecha('BOCINA', os.path.join(directorio, 'v_flecha8.png'))
+		self.flechas['CELULAR'] = Flecha('CELULAR', os.path.join(directorio, 'flecha2.png'))
+		self.flechas['ATRAS'] = Flecha('ATRAS', os.path.join(directorio, 'flecha3.png'))
+		self.flechas['CODERA'] = Flecha('CODERA', os.path.join(directorio, 'flecha4.png'))
+		self.flechas['MUSICA'] = Flecha('MUSICA', os.path.join(directorio, 'flecha6.png'))
+		for key in self.flechas.keys():
+			flecha = self.flechas[key]
+			flecha.connect(callback = self.main.deja, sonido_select = None)
+			self.add(flecha)
+
+		fuente, tamanio = JAMG.get_Font_fawn()
+		for linea in G.get_Texto_FGR_T0502():
+			label = JAMLabel(linea)
+			label.set_font_from_file(fuente, tamanio = 28)
+			label.set_text(color = (255,255,255,255))
+			self.textos.append(label)
+
+	def set_posicion(self, punto = (0,0)):
+		pos = punto
+		x, y = pos
+		w, h = (0,0)
+		for fila in self.matriz_letras:
+			for letra in fila:
+				letra.set_posicion( (x,y) )
+				w,h = letra.get_tamanio()
+				x += w
+			y += h
+			x = pos[0]
+
+		# Verticales
+		flecha = self.flechas['CHALECO']
+		elemento = self.matriz_letras[0][0]
+		((a,b), (c,d)) = (elemento.get_posicion(), flecha.get_tamanio())
+		flecha.set_posicion( (a,b-d) )
+		flecha = self.flechas['MATE']
+		elemento = self.matriz_letras[4][5]
+		((a,b), (c,d)) = (elemento.get_posicion(), flecha.get_tamanio())
+		flecha.set_posicion( (a,b-d) )
+		flecha = self.flechas['SRI']
+		elemento = self.matriz_letras[4][7]
+		((a,b), (c,d)) = (elemento.get_posicion(), flecha.get_tamanio())
+		flecha.set_posicion( (a,b-d) )
+		flecha = self.flechas['BOCINA']
+		elemento = self.matriz_letras[2][9]
+		((a,b), (c,d)) = (elemento.get_posicion(), flecha.get_tamanio())
+		flecha.set_posicion( (a,b-d) )
+		# Horizontales
+		flecha = self.flechas['CELULAR']
+		elemento = self.matriz_letras[0][0]
+		((a,b), (c,d)) = (elemento.get_posicion(), flecha.get_tamanio())
+		flecha.set_posicion( (a-c,b) )
+		flecha = self.flechas['ATRAS']
+		elemento = self.matriz_letras[2][0]
+		((a,b), (c,d)) = (elemento.get_posicion(), flecha.get_tamanio())
+		flecha.set_posicion( (a-c,b) )
+		flecha = self.flechas['CODERA']
+		elemento = self.matriz_letras[5][0]
+		((a,b), (c,d)) = (elemento.get_posicion(), flecha.get_tamanio())
+		flecha.set_posicion( (a-c,b) )
+		flecha = self.flechas['MUSICA']
+		elemento = self.matriz_letras[4][5]
+		((a,b), (c,d)) = (elemento.get_posicion(), flecha.get_tamanio())
+		flecha.set_posicion( (a-c,b) )
+
+		ultimo = self.matriz_letras[-1][-1]
+		x, y = ultimo.get_posicion()
+		w, h = ultimo.get_tamanio()
+		posbuttons = (x+w,y+h)
+
+		for fila in self.matriz_letras:
+			for letra in fila:
+				if not letra.letra:
+					fila.remove(letra)
+					letra.kill()
+		y = posbuttons[1] + 50
+		for boton in self.botones[4:]:
+			w,h = boton.get_tamanio()
+			x = posbuttons[0] - w
+			boton.set_posicion( (x, y) )
+			y += h + 10
+		y = posbuttons[1] + 50
+		posbuttons = (posbuttons[0] - (w+10), posbuttons[1])
+		for boton in self.botones[:4]:
+			w,h = boton.get_tamanio()
+			x = posbuttons[0] - w
+			boton.set_posicion( (x, y) )
+			y += h + 10
+
+		x, y = (G.RESOLUCION[0]/2 + 115, 135)
+		for label in self.textos:
+			label.set_posicion((x,y))
+			y += label.get_tamanio()[1]+10
+
+		a,b,c,d = (0,0,0,0)
+		a,b = self.textos[0].get_posicion()
+		for label in self.textos:
+			e,f = label.get_tamanio()
+			if e > c: c = e
+			if f > d: d = f
+		sombra = JAMG.get_Sombra((c+40, self.textos[-1].get_posicion()[1]-b + d + 40),
+			(92,193,235,255), 80)
+		sombra = sombra.sprites()[0]
+		sombra.rect.x, sombra.rect.y = (a-20, b-20)
+		self.add(sombra)
+		for label in self.textos:
+			self.add(label)
+
+	def seleccionar(self, boton):
+		for bot in self.botones:
+			if not bot.ubicado:
+				bot.connect(callback = self.main.toma, sonido_select = None)
+				bot.reset()
+		boton.connect(callback = None, sonido_select = None)
+		boton.seleccionar()
+
+	def marcar(self, flecha):
+		for letra in self.palabras[flecha.nombre]:
+			letra.set_text(texto = letra.letra)
+			flecha.kill()
+
+class Boton(JAMButton):
+	def __init__(self, texto):
+		JAMButton.__init__(self, texto, None)
+		self.ubicado = False
+		fuente, tamanio = JAMG.get_Font_fawn()
+		self.set_font_from_file(fuente, tamanio = 30)
+		self.set_tamanios(tamanio = (150, 25), grosorbor=1, detalle=1, espesor=1)
+		self.colorcara, self.colorbase, self.colorborde, g, d, e = JAMG.get_default_jambutton_values()
+		self.colormarca = (92,193,235,255)
 		self.reset()
 	def reset(self):
-		self.final_unselect = self.imagen1.copy()
-		self.final_select = JAMG.get_my_surface_whit_border(self.imagen1.copy(), (255,255,255,255), 10)
-		self.image = self.final_unselect
+		self.set_colores(colorbas = self.colorbase,
+			colorbor = self.colorborde, colorcara = self.colorcara)
 	def seleccionar(self):
-		self.final_unselect = self.imagen2.copy()
-		self.final_select = self.imagen2.copy()
+		self.set_colores(colorbas = self.colormarca,
+			colorbor = self.colormarca, colorcara = self.colormarca)
+	def marcar(self):
+		self.ubicado = True
+		self.connect(callback = None, sonido_select = None)
+		self.set_colores(colorbas = self.colorbase,
+			colorbor = self.colorbase, colorcara = self.colorbase)
+
+class Flecha(JAMButton):
+	def __init__(self, nombre, imagen):
+		JAMButton.__init__(self, '',imagen)
+		self.nombre = nombre
+		self.set_tamanios(tamanio = (50, 50), grosorbor=1, detalle=1, espesor=1)
+		imagen = pygame.image.load(imagen)
+		self.final_select = JAMG.get_Rectangulo((240,150,0,255), (50,50))
+		self.final_select.blit(imagen,(0,0))
+		self.final_unselect = imagen
 		self.image = self.final_unselect
+		self.rect = self.image.get_rect()
 
-# -------- SEÑALES ----------
+class Letra(JAMButton):
+	def __init__(self, letra):
+		JAMButton.__init__(self, '',None)
+		fuente, tamanio = JAMG.get_Font_fawn()
+		self.set_font_from_file(fuente, tamanio = 30)
+		self.letra = letra
+		#if self.letra: self.set_text(texto = self.letra)
+		self.set_tamanios(tamanio = (50, 50), grosorbor=1, detalle=1, espesor=1)
+	def update(self):
+		pass
 
 # --------- TEXTOS ----------------
 class Textos_Intro(pygame.sprite.OrderedUpdates):
 	def __init__(self):
 		pygame.sprite.OrderedUpdates.__init__(self)
-		self.base = None
-		self.labels = []
-		self.gruber = None
+		self.base= None
+		self.labels= []
+		self.gruber= None
+		self.base= None
 
 		self.load_textos()
 		self.set_posicion_labels()
-		self.base = self.get_base()
-		self.gruber = self.get_gruber()
+		self.base= self.get_base()
+		self.gruber= self.get_gruber()
 
 		self.add(self.base)
 		self.add(self.labels)
 		self.add(self.gruber)
 
 	def get_gruber(self):
-		gruber = pygame.sprite.Sprite()
-		gruber.image = G.get_Imagen_Gruber1()
-		gruber.rect = gruber.image.get_rect()
-		w,h = G.RESOLUCION
+		gruber= pygame.sprite.Sprite()
+		gruber.image= G.get_Imagen_Gruber1()
+		gruber.rect= gruber.image.get_rect()
+		w,h= G.RESOLUCION
 		gruber.rect.x, gruber.rect.y= (w/2-gruber.rect.w/2, self.base.rect.y-gruber.rect.h)
 		return gruber
 
 	def get_base(self):
-		w,h = self.get_dimensiones()
-		w += 20
-		h += 20
-		base = pygame.sprite.Sprite()
+		w,h= self.get_dimensiones()
+		w+= 20
+		h+= 20
+		base= pygame.sprite.Sprite()
 		superficie = pygame.Surface( (w,h), flags=SRCALPHA )
 		superficie.fill((0,0,0,150))
-		base.image = superficie
-		base.rect = base.image.get_rect()
-		base.rect.x, base.rect.y = (G.RESOLUCION[0]/2-base.rect.w/2, self.labels[0].rect.y-10)
+		base.image= superficie
+		base.rect= base.image.get_rect()
+		base.rect.x, base.rect.y= (G.RESOLUCION[0]/2-base.rect.w/2, self.labels[0].rect.y-10)
 		return base
 		
 	def load_textos(self):
-		textos = G.get_Textos_FGR_T0101()
+		textos= G.get_Textos_FGR_T0301()
 		for linea in textos:
-			label = Sprite_Texto(linea)
+			label= Sprite_Texto(linea)
 			self.labels.append(label)
 
 	def set_posicion_labels(self):
-		w,h = G.RESOLUCION
-		x, y = (0,h/2-30)
+		w,h= G.RESOLUCION
+		x, y= (0,h/2-30)
 		for label in self.labels:
-			x = w/2-label.rect.w/2
-			label.rect.x = x
-			label.rect.y = y
-			y += label.rect.h
+			x= w/2-label.rect.w/2
+			label.rect.x= x
+			label.rect.y= y
+			y+= label.rect.h
 
 	def get_dimensiones(self):
-		w,h = (0,0)
+		w,h= (0,0)
 		for label in self.labels:
-			if label.rect.w > w: w = label.rect.w
-			h += label.rect.h
+			if label.rect.w > w: w= label.rect.w
+			h+= label.rect.h
 		return (w,h)
 
 class Sprite_Texto(pygame.sprite.Sprite):
 	def __init__(self, texto):
 		pygame.sprite.Sprite.__init__(self)
-		string_to_render = ""
-		fuente = self.get_Font()
+		string_to_render= ""
+		fuente= self.get_Font()
 		string_to_render = unicode( texto.decode("utf-8") )
 		self.image = fuente.render(string_to_render, 1, JAMG.get_blanco())
-		self.rect = self.image.get_rect()
+		self.rect= self.image.get_rect()
 
 	def get_Font(self):
-		fuente, tamanio = JAMG.get_Font_fawn()
+		fuente, tamanio= JAMG.get_Font_fawn()
 		return pygame.font.Font(fuente, tamanio)
 # --------- TEXTOS ----------------
 
@@ -662,23 +653,22 @@ class ButtonsMenu(pygame.sprite.OrderedUpdates):
 		pygame.sprite.OrderedUpdates.__init__(self)
 		self.main = main
 		imagen = G.get_Flecha()
-
 		salir = JAMButton("",None)
 		salir.set_imagen(origen = imagen, tamanio=(100,55))
-		salir.set_colores(colorbas =JAMG.get_negro(), colorcara=JAMG.get_negro())
-		salir.set_tamanios(tamanio =(0,0), grosorbor=1, detalle=1, espesor=1)
-		salir.set_posicion(punto = (10,10))
-		salir.connect (callback = self.main.run_dialog_intro)
+		salir.set_colores(colorbas=JAMG.get_negro(), colorcara=JAMG.get_negro())
+		salir.set_tamanios(tamanio=(0,0), grosorbor=1, detalle=1, espesor=1)
+		salir.set_posicion(punto= (10,10))
+		#salir.connect (callback = self.main.run_dialog_intro)
+		salir.connect (callback = self.main.salir, sonido_select = None)
 		self.add(salir)
-
-		jugar = JAMButton("Jugar",None)
+		jugar= JAMButton("Jugar",None)
 		jugar.set_text(color=JAMG.get_blanco())
-		fuente, tamanio = JAMG.get_Font_fawn()
+		fuente, tamanio= JAMG.get_Font_fawn()
 		jugar.set_font_from_file(fuente, tamanio= 50)
 		jugar.set_colores(colorbas=JAMG.get_negro(), colorcara=JAMG.get_negro())
 		jugar.set_tamanios(tamanio=(200,0), grosorbor=1, detalle=1, espesor=1)
-		w,h = G.RESOLUCION
-		ww,hh = jugar.get_tamanio()
+		w,h= G.RESOLUCION
+		ww,hh= jugar.get_tamanio()
 		jugar.set_posicion(punto= (w-ww-10,h-hh-10))
 		jugar.connect (callback= self.run_Instruc)
 		self.add(jugar)
@@ -699,23 +689,29 @@ class ButtonsMenu(pygame.sprite.OrderedUpdates):
 class Mensaje(pygame.sprite.OrderedUpdates):
 	def __init__(self, main, opcion, text1, text2):
 		pygame.sprite.OrderedUpdates.__init__(self)
+		self.main= main
 		self.estado= True
+
 		self.base= None
 		self.label1= None
 		self.label2= None
 		self.labels= []
 		self.gruber= None
+
 		self.label1= Sprite_Texto(text1)
 		self.label2= Sprite_Texto(text2)
 		self.labels= [self.label1, self.label2]
+
 		self.x_final_label1= 0
 		self.x_final_label2= 0
+
 		self.init()
 		self.base= self.get_base()
 		if opcion== "Victory":
 			self.gruber= self.get_gruber2()
 		elif opcion== "End":
 			self.gruber= self.get_gruber3()
+
 		self.add(self.base)
 		self.add(self.labels)
 		self.add(self.gruber)
@@ -724,10 +720,12 @@ class Mensaje(pygame.sprite.OrderedUpdates):
 		w,h= G.RESOLUCION
 		w1,h1= (self.label1.rect.w, self.label1.rect.h)
 		w2,h2= (self.label2.rect.w, self.label2.rect.h)
+
 		x= 0-w
 		y= h/2-h2/2
 		self.label2.rect.x, self.label2.rect.y= (x,y)
 		self.x_final_label2= w/2-w2/2
+
 		x= w
 		y= self.label2.rect.y - h2
 		self.label1.rect.x, self.label1.rect.y= (x,y)
@@ -777,6 +775,7 @@ class Mensaje(pygame.sprite.OrderedUpdates):
 			final= False
 		else:
 			self.label2.rect.x= self.x_final_label2
+
 		x,y,w,h= self.label1.rect
 		if x > self.x_final_label1:	
 			x-= 60
@@ -784,6 +783,7 @@ class Mensaje(pygame.sprite.OrderedUpdates):
 			final= False
 		else:
 			self.label1.rect.x= self.x_final_label1
+
 		if final== True:
 			self.label2.rect.x= self.x_final_label2
 			self.label1.rect.x= self.x_final_label1