def __init__(self, main):
pygame.sprite.OrderedUpdates.__init__(self)
self.main = main
self.botones = {}
for imagen in os.listdir(IMAGENES):
sonido = os.path.basename(imagen).split(".")[0] + ".ogg"
imagen = os.path.join(IMAGENES, imagen)
boton = JAMButton("", imagen)
boton.set_imagen(origen=imagen)
boton.set_tamanios(tamanio=(190, 180), grosorbor=1, espesor=1)
self.add(boton)
jam_label = JAMLabel("Cantando . . .")
jam_label.set_text(tamanio=25, color=(255, 0, 0, 1))
self.botones[boton] = [sonido, jam_label, False, sonido]
boton.connect(callback=self.play_canto, sonido_select=None)
x = 0
y = 0
contador = 0
for boton in self.sprites():
boton.set_posicion(punto=(x, y))
x += 200
contador += 1
if contador == 6:
x = 0
y += boton.get_tamanio()[1]
contador = 0
def __init__(self, main):
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.connect (callback = self.main.salir, sonido_select = None)
self.add(salir)
jugar = JAMButton("Jugar",None)
jugar.set_text(color=JAMG.get_blanco())
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()
jugar.set_posicion(punto= (w-ww-10,h-hh-10))
jugar.connect (callback= self.run_Instruc)
self.add(jugar)
def get_botones_letras(self):
simbols = JAMG.get_letras_up()
botones_letras = []
for letra in simbols:
boton = JAMButton(letra, None)
boton.set_font_from_file(self.fuente, tamanio=20)
boton.set_tamanios(tamanio=(0, 0),
grosorbor=1,
detalle=1,
espesor=1)
boton.set_colores(colorbas=(0, 153, 255, 255),
colorbor=(0, 153, 255, 255),
colorcara=(255, 255, 255, 255))
#boton.set_text(color = (0,153,255,255))
boton.connect(callback=self.set_buffer, sonido_select=None)
botones_letras.append(boton)
simbols = JAMG.get_numeros()
botones_numeros = []
for letra in simbols:
boton = JAMButton(letra, None)
boton.set_font_from_file(self.fuente, tamanio=20)
boton.set_tamanios(tamanio=(0, 0),
grosorbor=1,
detalle=1,
espesor=1)
boton.set_colores(colorbas=(0, 153, 255, 255),
colorbor=(0, 153, 255, 255),
colorcara=(255, 255, 255, 255))
#boton.set_text(color = (0,153,255,255))
boton.connect(callback=self.set_buffer, sonido_select=None)
botones_numeros.append(boton)
botones_especiales = []
for letra in ['', ' ', '']:
boton = JAMButton(letra, None)
#boton.set_font_from_file(self.fuente, tamanio = 20)
boton.set_tamanios(tamanio=(0, 0),
grosorbor=1,
detalle=1,
espesor=1)
boton.set_colores(colorbas=(0, 153, 255, 255),
colorbor=(0, 153, 255, 255),
colorcara=(255, 255, 255, 255))
#boton.set_text(color = (0,153,255,255))
boton.connect(callback=self.set_buffer, sonido_select=None)
botones_especiales.append(boton)
imagen = os.path.join(G.IMAGENES, "back.png")
boton = botones_especiales[0]
boton.set_imagen(origen=imagen)
boton.connect(callback=self.set_back_space, sonido_select=None)
imagen = os.path.join(G.IMAGENES, "enter.png")
boton = botones_especiales[2]
boton.set_imagen(origen=imagen)
boton.connect(callback=self.set_enter, sonido_select=None)
return (botones_letras, botones_numeros, botones_especiales)
class Main():
def __init__(self, res):
self.resolucionreal = res
self.ventana = None
self.name = "JAMClock"
self.ventana_real = None
self.VA = None
self.VH = None
# Variables del Juego
self.fondo = None
self.reloj = None
self.estado = False
self.sonidoalarma = None
self.duracionalarma = None
self.jamclock = None
self.jamcalendar = None
self.cerrar = None
self.controlalarma = None
self.controles = None
self.mensaje = None
self.dialog = None
self.preset()
self.load()
self.run()
def preset(self):
pygame.display.set_mode((0, 0), pygame.DOUBLEBUF | pygame.FULLSCREEN,
0)
A, B = RESOLUCION
self.ventana = pygame.Surface((A, B), flags=HWSURFACE)
self.ventana_real = pygame.display.get_surface()
C, D = (0, 0)
if self.resolucionreal:
C, D = self.resolucionreal
else:
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)
def load(self):
pygame.event.set_blocked([
JOYAXISMOTION, JOYBALLMOTION, JOYHATMOTION, JOYBUTTONUP,
JOYBUTTONDOWN
])
pygame.event.set_allowed([
MOUSEMOTION, MOUSEBUTTONUP, MOUSEBUTTONDOWN, KEYDOWN, KEYUP,
VIDEORESIZE, VIDEOEXPOSE, USEREVENT, QUIT, ACTIVEEVENT
])
pygame.mouse.set_visible(True)
a, b, c = JAMG.get_estilo_papel_quemado()
if not self.reloj: self.reloj = pygame.time.Clock()
if not self.fondo: self.fondo = self.get_fondo(color=b)
if not self.dialog:
self.dialog = JAMDialog()
self.dialog.set_text(tamanio=24)
d, e, f = JAMG.get_estilo_celeste()
self.dialog.set_colors_dialog(base=e, bordes=f)
self.dialog.set_colors_buttons(colorbas=a, colorbor=b, colorcara=c)
self.dialog.set_text_buttons(tamanio=24)
if not pygame.mixer.get_init():
pygame.mixer.init(44100, -16, 2, 2048)
pygame.mixer.music.set_volume(1.0)
if not self.controles: self.controles = pygame.sprite.OrderedUpdates()
if not self.cerrar:
self.cerrar = JAMButton("", JAMG.get_icon_exit())
self.cerrar.set_imagen(origen=JAMG.get_icon_exit(),
tamanio=(20, 20))
self.cerrar.set_tamanios(tamanio=(0, 0), grosorbor=1, espesor=1)
self.cerrar.set_colores(colorbas=a, colorbor=b, colorcara=c)
x = RESOLUCION[0] - self.cerrar.get_tamanio()[0]
self.cerrar.set_posicion(punto=(x, 0))
self.cerrar.connect(callback=self.selecciona_mensaje_salir)
if not self.jamclock:
self.jamclock = JAMClock()
self.jamclock.set_tamanios(2)
self.jamclock.set_colors_base(c, a)
y = self.cerrar.get_tamanio()[1] + SEPARADOR
self.jamclock.set_posicion(punto=(SEPARADOR, y))
self.sonidoalarma = JAMG.get_alarma_reloj1()
self.duracionalarma = 30
if not self.jamcalendar:
self.jamcalendar = JAMCalendar()
self.jamcalendar.set_gama_colors(colorselect=a,
colorbor=b,
colorcara=c)
self.jamcalendar.set_text(tamanio=24)
x = RESOLUCION[0] - self.jamcalendar.get_tamanio()[0] - SEPARADOR
y = self.cerrar.get_tamanio()[1] + SEPARADOR
self.jamcalendar.set_posicion(punto=(x, y))
if not self.controlalarma:
self.controlalarma = ControlAlarma()
x, y = self.jamcalendar.get_posicion()
w, h = self.jamcalendar.get_tamanio()
x = x + w / 2 - self.controlalarma.get_tamanio()[0] / 2
y += h + SEPARADOR * 5
self.controlalarma.set_posicion(punto=(x, y))
self.controlalarma.boton_active.connect(
callback=self.active_alarma)
self.controles.add(self.jamclock)
self.controles.add(self.jamcalendar)
self.controles.add(self.cerrar)
self.controles.add(self.controlalarma)
self.load_conf()
self.estado = True
def load_conf(self):
alarma = Abrir()
alarma = alarma.split(":")
self.controlalarma.horas = int(alarma[0])
self.controlalarma.minutos = int(alarma[1])
self.controlalarma.etiqueta_tiempo.set_text(
texto="%s:%s" %
(self.controlalarma.horas, self.controlalarma.minutos))
self.active_alarma(None)
def active_alarma(self, button=None):
horas, minutos = self.controlalarma.get_time()
if self.controlalarma.active:
self.jamclock.set_alarma((100, 100), self.sonidoalarma,
self.duracionalarma)
self.controlalarma.set_active(False)
elif not self.controlalarma.active:
self.jamclock.set_alarma((horas, minutos), self.sonidoalarma,
self.duracionalarma)
self.controlalarma.set_active(True)
Guardar("%s:%s" % (horas, minutos))
def run(self):
self.ventana.blit(self.fondo, (0, 0))
self.controles.draw(self.ventana)
pygame.display.update()
while self.estado:
self.reloj.tick(35)
while gtk.events_pending():
gtk.main_iteration(False)
Traduce_posiciones(self.VA, self.VH)
if self.mensaje:
self.pause_game()
self.controles.clear(self.ventana, self.fondo)
self.controles.update()
self.handle_event()
pygame.event.clear()
self.controles.draw(self.ventana)
self.ventana_real.blit(
pygame.transform.scale(self.ventana, self.resolucionreal),
(0, 0))
pygame.display.update()
def handle_event(self):
for event in pygame.event.get(pygame.KEYDOWN):
tecla = event.key
if tecla == pygame.K_ESCAPE:
pygame.event.clear()
return self.selecciona_mensaje_salir()
def pause_game(self):
while self.mensaje.sprites():
self.reloj.tick(35)
while gtk.events_pending():
gtk.main_iteration(False)
Traduce_posiciones(self.VA, self.VH)
self.controles.clear(self.ventana, self.fondo)
self.mensaje.clear(self.ventana, self.fondo)
self.mensaje.update()
pygame.event.clear()
self.controles.draw(self.ventana)
self.mensaje.draw(self.ventana)
self.ventana_real.blit(
pygame.transform.scale(self.ventana, self.resolucionreal),
(0, 0))
pygame.display.update()
def deselecciona_mensaje(self, boton):
self.mensaje = pygame.sprite.OrderedUpdates()
def selecciona_mensaje_salir(self, button=None):
self.dialog.set_text(texto="¿ Salir de JAMClock ?")
self.dialog.connect(funcion_ok=self.salir,
funcion_cancel=self.deselecciona_mensaje)
self.mensaje = self.dialog
def get_fondo(self, color=(100, 100, 100, 1), tamanio=RESOLUCION):
superficie = pygame.Surface(tamanio, flags=HWSURFACE)
superficie.fill(color)
img = pygame.image.load("firma.png")
ww, hh = RESOLUCION
w, h = img.get_size()
x = ww / 2 - w / 2
y = hh - h - SEPARADOR
superficie.blit(img, (x, y))
return superficie
def salir(self, boton):
sys.exit()
class ControlAlarma(pygame.sprite.OrderedUpdates):
def __init__(self):
pygame.sprite.OrderedUpdates.__init__(self)
self.base = None
self.etiqueta = None
self.etiqueta_tiempo = None
self.boton_active = None
self.botonminutos_down = None
self.botonminutos_up = None
self.botonhoras_down = None
self.botonhoras_up = None
self.active = False
self.horas = 12
self.minutos = 00
self.load()
self.botonminutos_up.connect(callback=self.next)
self.botonminutos_down.connect(callback=self.back)
self.botonhoras_up.connect(callback=self.nexthoras)
self.botonhoras_down.connect(callback=self.backhoras)
def set_active(self, valor):
if valor:
self.active = True
self.boton_active.set_imagen(origen=JAMG.get_icon_ok(),
tamanio=(20, 20))
elif not valor:
self.active = False
self.boton_active.set_imagen(origen=JAMG.get_icon_cancel(),
tamanio=(20, 20))
def next(self, button=None):
if self.minutos >= 59:
self.minutos = 0
self.horas += 1
elif self.minutos < 59:
self.minutos += 1
if self.horas >= 24:
self.horas = 0
self.etiqueta_tiempo.set_text(texto="%s:%s" %
(self.horas, self.minutos))
self.set_active(False)
def back(self, button=None):
if self.minutos <= 1:
self.minutos = 59
self.horas -= 1
elif self.minutos > 0:
self.minutos -= 1
if self.horas < 0:
self.horas = 23
self.etiqueta_tiempo.set_text(texto="%s:%s" %
(self.horas, self.minutos))
self.set_active(False)
def nexthoras(self, button=None):
if self.horas >= 23:
self.horas = 0
elif self.horas < 23:
self.horas += 1
self.etiqueta_tiempo.set_text(texto="%s:%s" %
(self.horas, self.minutos))
self.set_active(False)
def backhoras(self, button=None):
if self.horas <= 23 and self.horas > 0:
self.horas -= 1
elif self.horas <= 0:
self.horas = 23
self.etiqueta_tiempo.set_text(texto="%s:%s" %
(self.horas, self.minutos))
self.set_active(False)
def load(self):
a, b, c = JAMG.get_estilo_papel_quemado()
self.etiqueta = Etiqueta("Alarma")
self.etiqueta.set_colores(colorbas=a, colorbor=b, colorcara=c)
self.etiqueta.set_tamanios(tamanio=(0, 0), grosorbor=1, espesor=1)
self.etiqueta.set_text(tamanio=24)
self.etiqueta_tiempo = Etiqueta("%s:%s" % (self.horas, self.minutos))
self.etiqueta_tiempo.set_tamanios(tamanio=(0, 0),
grosorbor=1,
espesor=1)
self.etiqueta_tiempo.set_text(tamanio=40)
self.botonminutos_down = JAMButton("", "down.png")
self.botonminutos_down.set_imagen(origen="down.png", tamanio=(20, 20))
self.botonminutos_down.set_colores(colorbas=a, colorbor=b, colorcara=c)
self.botonminutos_down.set_tamanios(tamanio=(0, 0),
grosorbor=1,
espesor=1)
self.botonminutos_up = JAMButton("", "up.png")
self.botonminutos_up.set_imagen(origen="up.png", tamanio=(20, 20))
self.botonminutos_up.set_colores(colorbas=a, colorbor=b, colorcara=c)
self.botonminutos_up.set_tamanios(tamanio=(0, 0),
grosorbor=1,
espesor=1)
self.botonhoras_down = JAMButton("", "down.png")
self.botonhoras_down.set_imagen(origen="down.png", tamanio=(20, 20))
self.botonhoras_down.set_colores(colorbas=a, colorbor=b, colorcara=c)
self.botonhoras_down.set_tamanios(tamanio=(0, 0),
grosorbor=1,
espesor=1)
self.botonhoras_up = JAMButton("", "up.png")
self.botonhoras_up.set_imagen(origen="up.png", tamanio=(20, 20))
self.botonhoras_up.set_colores(colorbas=a, colorbor=b, colorcara=c)
self.botonhoras_up.set_tamanios(tamanio=(0, 0), grosorbor=1, espesor=1)
self.boton_active = JAMButton("", JAMG.get_icon_ok())
self.boton_active.set_imagen(origen=JAMG.get_icon_ok(),
tamanio=(20, 20))
self.boton_active.set_colores(colorbas=a, colorbor=b, colorcara=c)
self.boton_active.set_tamanios(tamanio=(0, 0), grosorbor=1, espesor=1)
self.base = self.get_base(color=b, tamanio=self.geometria())
w = self.get_tamanio()[0] - sep * 2
self.etiqueta_tiempo.set_tamanios(tamanio=(w, 0),
grosorbor=1,
espesor=1)
self.add([
self.base, self.etiqueta, self.etiqueta_tiempo,
self.botonminutos_up, self.botonminutos_down, self.botonhoras_up,
self.botonhoras_down, self.boton_active
])
self.set_posicion(punto=(0, 0))
def geometria(self):
ancho, alto = (200, 130)
return (ancho, alto)
def get_base(self, color=(100, 100, 100, 1), tamanio=(100, 100)):
base = pygame.sprite.Sprite()
superficie = pygame.Surface(tamanio, flags=HWSURFACE)
superficie.fill(color)
base.image = superficie
base.rect = base.image.get_rect()
return base
def set_posicion(self, punto=(0, 0)):
x, y = punto
self.base.rect.x, self.base.rect.y = (x, y)
x += sep
y += sep
# ---
xx = self.base.rect.x + self.base.rect.w / 2 - self.etiqueta.get_tamanio(
)[0] / 2
self.etiqueta.set_posicion(punto=(xx, y))
y += self.etiqueta.get_tamanio()[1] + sep
xx = self.base.rect.x + self.base.rect.w / 2 - self.etiqueta_tiempo.get_tamanio(
)[0] / 2
self.etiqueta_tiempo.set_posicion(punto=(xx, y))
# ---
x, y = self.etiqueta_tiempo.get_posicion()
xx, hh = self.botonminutos_up.get_tamanio()
x += self.etiqueta_tiempo.get_tamanio(
)[0] - self.botonminutos_up.get_tamanio()[0]
y -= self.botonminutos_up.get_tamanio(
)[1] - self.etiqueta_tiempo.get_tamanio()[1] / 2
self.botonminutos_up.set_posicion(punto=(x, y))
x, y = self.botonminutos_up.get_posicion()
y += self.botonminutos_up.get_tamanio()[1]
self.botonminutos_down.set_posicion(punto=(x, y))
x, y = self.etiqueta_tiempo.get_posicion()
xx, hh = self.botonhoras_up.get_tamanio()
y -= self.botonhoras_up.get_tamanio(
)[1] - self.etiqueta_tiempo.get_tamanio()[1] / 2
self.botonhoras_up.set_posicion(punto=(x, y))
x, y = self.botonhoras_up.get_posicion()
y += self.botonhoras_up.get_tamanio()[1]
self.botonhoras_down.set_posicion(punto=(x, y))
x, y = self.etiqueta_tiempo.get_posicion()
w, h = self.etiqueta_tiempo.get_tamanio()
ww, yy = self.boton_active.get_tamanio()
x += w / 2 - ww / 2
y += sep + h
self.boton_active.set_posicion(punto=(x, y))
def get_tamanio(self):
return (self.base.rect.w, self.base.rect.h)
def get_time(self):
return (self.horas, self.minutos)
def __init__(self, main):
self.main = main
pygame.sprite.OrderedUpdates.__init__(self)
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.emit_volver, sonido_select=None)
self.add(salir)
imagen = main.usuario['personaje']
user = JAMButton(main.usuario['nombre'], None)
user.set_imagen(origen=imagen, tamanio=(60, 60))
user.set_colores(colorbas=(0, 153, 255, 255),
colorbor=(0, 153, 255, 255),
colorcara=(0, 153, 255, 255))
user.set_tamanios(tamanio=(80, 80), grosorbor=1, detalle=1, espesor=1)
ww, hh = user.get_tamanio()
w, h = G.RESOLUCION
user.set_posicion(punto=(w - ww - 10, 10))
user.connect(callback=None, sonido_select=None)
self.add(user)
uno = BotonGrupo()
uno.set_tamanios(tamanio=(0, 0), grosorbor=1, detalle=1, espesor=1)
imagen = os.path.join(G.IMAGENES, "Menu", "img1.png")
uno.set_imagen(origen=imagen)
uno.connect(callback=main.run_grupo1, sonido_select=None)
self.add(uno)
dos = BotonGrupo()
dos.set_tamanios(tamanio=(0, 0), grosorbor=1, detalle=1, espesor=1)
imagen = os.path.join(G.IMAGENES, "Menu", "img2.png")
dos.set_imagen(origen=imagen)
dos.connect(callback=main.run_grupo2, sonido_select=None)
self.add(dos)
tres = BotonGrupo()
tres.set_tamanios(tamanio=(0, 0), grosorbor=1, detalle=1, espesor=1)
imagen = os.path.join(G.IMAGENES, "Menu", "img3.png")
tres.set_imagen(origen=imagen)
tres.connect(callback=main.run_grupo3, sonido_select=None)
self.add(tres)
cuatro = BotonGrupo()
cuatro.set_tamanios(tamanio=(0, 0), grosorbor=1, detalle=1, espesor=1)
imagen = os.path.join(G.IMAGENES, "Menu", "img4.png")
cuatro.set_imagen(origen=imagen)
cuatro.connect(callback=main.run_grupo4, sonido_select=None)
self.add(cuatro)
cinco = BotonGrupo()
cinco.set_tamanios(tamanio=(0, 0), grosorbor=1, detalle=1, espesor=1)
imagen = os.path.join(G.IMAGENES, "Menu", "img5.png")
cinco.set_imagen(origen=imagen)
cinco.connect(callback=main.run_grupo5, sonido_select=None)
self.add(cinco)
presenta = BotonPresentacion()
presenta.connect(callback=main.presentacion, sonido_select=None)
self.add(presenta)
sep = 50
w, h = G.RESOLUCION
ww, hh = dos.get_tamanio()
dos.set_posicion((w / 2 - ww / 2, h / 2 - hh))
x, y = dos.get_posicion()
tres.set_posicion((x + ww + sep, y))
uno.set_posicion((x - ww - sep, y))
cuatro.set_posicion(((w / 2 - ww) - sep, y + hh + sep))
cinco.set_posicion((w / 2 + sep, y + hh + sep))
ww, hh = presenta.get_tamanio()
presenta.set_posicion((w - ww - 10, h - hh - 10))
def __init__(self, main):
pygame.sprite.OrderedUpdates.__init__(self)
fuente, tamanio = JAMG.get_Font_fawn()
self.main = main
self.posiciones_usuarios = (0, 0)
imagen = os.path.join(G.IMAGENES, "Login", "fondo_selecciona.png")
imagen = pygame.transform.scale(pygame.image.load(imagen), (427, 573))
self.fondo = pygame.sprite.Sprite()
self.fondo.image = (imagen)
self.fondo.rect = self.fondo.image.get_rect()
self.add(self.fondo)
self.label = JAMLabel("Selecciona tu Usuario")
self.label.set_font_from_file(fuente, tamanio=40)
self.label.set_text(color=(255, 255, 255, 255))
self.add(self.label)
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=main.run_dialog_intro)
self.add(salir)
self.upper = BotonScroll()
self.upper.set_imagen("up")
self.upper.connect(callback=self.up_user, sonido_select=None)
self.add(self.upper)
self.down = BotonScroll()
self.down.set_imagen("down")
self.down.connect(callback=self.down_user, sonido_select=None)
self.add(self.down)
usuarios = G.get_users()
self.usuarios = []
for user in usuarios:
usuario = Usuario(user)
usuario.connect(callback=self.emit_load_usuario,
sonido_select=None)
self.usuarios.append(usuario)
self.usuariosenmenu = None
if len(self.usuarios) <= 3:
self.usuariosenmenu = self.usuarios
else:
self.usuariosenmenu = self.usuarios[:3]
if self.usuariosenmenu: self.add(self.usuariosenmenu)
self.crear = JAMButton("Crear Nuevo", None)
self.crear.set_tamanios(grosorbor=1, detalle=1, espesor=1)
self.crear.set_font_from_file(fuente, tamanio=25)
self.crear.set_colores(colorbas=(0, 157, 224, 255),
colorbor=(0, 157, 224, 255),
colorcara=(92, 193, 235, 255))
self.crear.set_text(color=(255, 255, 255, 255))
self.crear.connect(callback=main.crear_usuario, sonido_select=None)
self.add(self.crear)
def __init__(self, main):
pygame.sprite.OrderedUpdates.__init__(self)
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=main.emit_volver, sonido_select=None)
self.add(salir)
imagen = main.usuario['personaje']
user = JAMButton(main.usuario['nombre'], None)
user.set_imagen(origen=imagen, tamanio=(60, 60))
user.set_colores(colorbas=(0, 153, 255, 255),
colorbor=(0, 153, 255, 255),
colorcara=(0, 153, 255, 255))
user.set_tamanios(tamanio=(80, 80), grosorbor=1, detalle=1, espesor=1)
ww, hh = user.get_tamanio()
w, h = G.RESOLUCION
user.set_posicion(punto=(w - ww - 10, 10))
user.connect(callback=None, sonido_select=None)
self.add(user)
if main.grupo == "grupo1":
grupo = BotonJuego()
grupo.set_tamanios(tamanio=(264, 264),
grosorbor=1,
detalle=1,
espesor=1)
imagen = os.path.join(G.IMAGENES, "Menu", "img1.png")
grupo.set_imagen(origen=imagen)
grupo.final_select = grupo.final_unselect
grupo.connect(callback=None, sonido_select=None)
self.add(grupo)
uno = BotonJuego()
uno.set_tamanios(tamanio=(264, 264),
grosorbor=1,
detalle=1,
espesor=1)
imagen = os.path.join(G.IMAGENES, "capturas", "101.jpg")
uno.set_imagen(origen=imagen)
uno.connect(callback=main.run_game11, sonido_select=None)
self.add(uno)
dos = BotonJuego()
dos.set_tamanios(tamanio=(264, 264),
grosorbor=1,
detalle=1,
espesor=1)
imagen = os.path.join(G.IMAGENES, "capturas", "102.jpg")
dos.set_imagen(origen=imagen)
dos.connect(callback=main.run_game12, sonido_select=None)
self.add(dos)
tres = BotonJuego()
tres.set_tamanios(tamanio=(264, 264),
grosorbor=1,
detalle=1,
espesor=1)
imagen = os.path.join(G.IMAGENES, "capturas", "103.jpg")
tres.set_imagen(origen=imagen)
tres.connect(callback=main.run_game13, sonido_select=None)
self.add(tres)
cuatro = BotonJuego()
cuatro.set_tamanios(tamanio=(264, 264),
grosorbor=1,
detalle=1,
espesor=1)
#imagen = os.path.join(G.IMAGENES, "capturas", "104.jpg")
#cuatro.set_imagen(origen = imagen)
cuatro.connect(callback=None, sonido_select=None)
#self.add(cuatro)
if main.grupo == "grupo2":
grupo = BotonJuego()
grupo.set_tamanios(tamanio=(264, 264),
grosorbor=1,
detalle=1,
espesor=1)
imagen = os.path.join(G.IMAGENES, "Menu", "img2.png")
grupo.set_imagen(origen=imagen)
grupo.final_select = grupo.final_unselect
grupo.connect(callback=None, sonido_select=None)
self.add(grupo)
uno = BotonJuego()
uno.set_tamanios(tamanio=(264, 264),
grosorbor=1,
detalle=1,
espesor=1)
imagen = os.path.join(G.IMAGENES, "capturas", "201.jpg")
uno.set_imagen(origen=imagen)
uno.connect(callback=main.run_game21, sonido_select=None)
self.add(uno)
dos = BotonJuego()
dos.set_tamanios(tamanio=(264, 264),
grosorbor=1,
detalle=1,
espesor=1)
imagen = os.path.join(G.IMAGENES, "capturas", "202.jpg")
dos.set_imagen(origen=imagen)
dos.connect(callback=main.run_game22, sonido_select=None)
self.add(dos)
tres = BotonJuego()
tres.set_tamanios(tamanio=(264, 264),
grosorbor=1,
detalle=1,
espesor=1)
#imagen = os.path.join(G.IMAGENES, "capturas", "203.jpg")
#tres.set_imagen(origen = imagen)
#tres.connect(callback = None, sonido_select = None)
#self.add(tres)
cuatro = BotonJuego()
cuatro.set_tamanios(tamanio=(264, 264),
grosorbor=1,
detalle=1,
espesor=1)
imagen = os.path.join(G.IMAGENES, "capturas", "204.jpg")
cuatro.set_imagen(origen=imagen)
cuatro.connect(callback=main.run_game24, sonido_select=None)
self.add(cuatro)
if main.grupo == "grupo3":
grupo = BotonJuego()
grupo.set_tamanios(tamanio=(264, 264),
grosorbor=1,
detalle=1,
espesor=1)
imagen = os.path.join(G.IMAGENES, "Menu", "img3.png")
grupo.set_imagen(origen=imagen)
grupo.final_select = grupo.final_unselect
grupo.connect(callback=None, sonido_select=None)
self.add(grupo)
uno = BotonJuego()
uno.set_tamanios(tamanio=(264, 264),
grosorbor=1,
detalle=1,
espesor=1)
imagen = os.path.join(G.IMAGENES, "capturas", "301.jpg")
uno.set_imagen(origen=imagen)
uno.connect(callback=main.run_game31, sonido_select=None)
self.add(uno)
dos = BotonJuego()
dos.set_tamanios(tamanio=(264, 264),
grosorbor=1,
detalle=1,
espesor=1)
imagen = os.path.join(G.IMAGENES, "capturas", "302.jpg")
dos.set_imagen(origen=imagen)
dos.connect(callback=main.run_game32, sonido_select=None)
self.add(dos)
tres = BotonJuego()
tres.set_tamanios(tamanio=(264, 264),
grosorbor=1,
detalle=1,
espesor=1)
imagen = os.path.join(G.IMAGENES, "capturas", "303.jpg")
tres.set_imagen(origen=imagen)
tres.connect(callback=main.run_game33, sonido_select=None)
self.add(tres)
cuatro = BotonJuego()
cuatro.set_tamanios(tamanio=(264, 264),
grosorbor=1,
detalle=1,
espesor=1)
#imagen = os.path.join(G.IMAGENES, "capturas", "304.jpg")
#cuatro.set_imagen(origen = imagen)
#cuatro.connect(callback = None, sonido_select = None)
#self.add(cuatro)
if main.grupo == "grupo4":
grupo = BotonJuego()
grupo.set_tamanios(tamanio=(264, 264),
grosorbor=1,
detalle=1,
espesor=1)
imagen = os.path.join(G.IMAGENES, "Menu", "img4.png")
grupo.set_imagen(origen=imagen)
grupo.final_select = grupo.final_unselect
grupo.connect(callback=None, sonido_select=None)
self.add(grupo)
uno = BotonJuego()
uno.set_tamanios(tamanio=(264, 264),
grosorbor=1,
detalle=1,
espesor=1)
imagen = os.path.join(G.IMAGENES, "capturas", "401.jpg")
uno.set_imagen(origen=imagen)
uno.connect(callback=main.run_game41, sonido_select=None)
self.add(uno)
dos = BotonJuego()
dos.set_tamanios(tamanio=(264, 264),
grosorbor=1,
detalle=1,
espesor=1)
imagen = os.path.join(G.IMAGENES, "capturas", "402.jpg")
dos.set_imagen(origen=imagen)
dos.connect(callback=main.run_game42, sonido_select=None)
self.add(dos)
tres = BotonJuego()
tres.set_tamanios(tamanio=(264, 264),
grosorbor=1,
detalle=1,
espesor=1)
#imagen = os.path.join(G.IMAGENES, "capturas", "403.jpg")
#tres.set_imagen(origen = imagen)
#tres.connect(callback = None, sonido_select = None)
#self.add(tres)
cuatro = BotonJuego()
cuatro.set_tamanios(tamanio=(264, 264),
grosorbor=1,
detalle=1,
espesor=1)
#imagen = os.path.join(G.IMAGENES, "capturas", "404.jpg")
#cuatro.set_imagen(origen = imagen)
#cuatro.connect(callback = None, sonido_select = None)
#self.add(cuatro)
if main.grupo == "grupo5":
grupo = BotonJuego()
grupo.set_tamanios(tamanio=(264, 264),
grosorbor=1,
detalle=1,
espesor=1)
imagen = os.path.join(G.IMAGENES, "Menu", "img5.png")
grupo.set_imagen(origen=imagen)
grupo.connect(callback=None, sonido_select=None)
self.add(grupo)
uno = BotonJuego()
uno.set_tamanios(tamanio=(264, 264),
grosorbor=1,
detalle=1,
espesor=1)
imagen = os.path.join(G.IMAGENES, "capturas", "501.jpg")
uno.set_imagen(origen=imagen)
uno.connect(callback=main.run_game51, sonido_select=None)
self.add(uno)
dos = BotonJuego()
dos.set_tamanios(tamanio=(264, 264),
grosorbor=1,
detalle=1,
espesor=1)
imagen = os.path.join(G.IMAGENES, "capturas", "502.jpg")
dos.set_imagen(origen=imagen)
dos.connect(callback=main.run_game52, sonido_select=None)
self.add(dos)
tres = BotonJuego()
tres.set_tamanios(tamanio=(264, 264),
grosorbor=1,
detalle=1,
espesor=1)
#imagen = os.path.join(G.IMAGENES, "capturas", "503.jpg")
#tres.set_imagen(origen = imagen)
#tres.connect(callback = main.run_game53, sonido_select = None)
#self.add(tres)
cuatro = BotonJuego()
cuatro.set_tamanios(tamanio=(264, 264),
grosorbor=1,
detalle=1,
espesor=1)
#imagen = os.path.join(G.IMAGENES, "capturas", "504.jpg")
#cuatro.set_imagen(origen = imagen)
#cuatro.connect(callback = main.run_game54, sonido_select = None)
#self.add(cuatro)
sep = 50
w, h = G.RESOLUCION
centrox = w / 2
centroy = h / 2
uno.set_posicion((centrox - sep * 3, centroy - uno.get_tamanio()[1]))
dos.set_posicion((uno.get_posicion()[0] + uno.get_tamanio()[0] + sep,
centroy - uno.get_tamanio()[1]))
tres.set_posicion((uno.get_posicion()[0], centroy + sep))
cuatro.set_posicion(
(tres.get_posicion()[0] + tres.get_tamanio()[0] + sep,
centroy + sep))
grupo.set_posicion((uno.get_posicion()[0] - uno.get_tamanio()[0] - sep,
uno.get_posicion()[1] + uno.get_tamanio()[1] / 2))
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.recuadro_select = None
self.progress_reloj = None
self.decorativas = None
self.sonidos_reloj = None
self.user = None
self.load_sprites()
def get_recuadro_select(self, tamanio):
''' Un Sprite para seleccionar las señales. '''
sup = JAMG.get_Rectangulo_Transparente(tamanio)
sup = JAMG.get_my_surface_whit_border(sup, JAMG.get_naranja1(), 10)
self.recuadro_select = pygame.sprite.Sprite()
self.recuadro_select.image = sup
self.recuadro_select.rect = self.recuadro_select.image.get_rect()
def get_labels_carteles(self, texto, centro):
''' Etiquetas sobre los carteles.'''
palabras = texto.split(" ")
renglon1 = "%s %s" % (palabras[0], palabras[1])
label = JAMLabel(renglon1)
label.set_text(color=JAMG.get_blanco())
fuente, tamanio = JAMG.get_Font_fawn()
label.set_font_from_file(fuente, tamanio=30)
x, y = centro
w, h = label.get_tamanio()
label.set_posicion(punto=(x - w / 2, y - h))
self.add(label)
if len(palabras) > 2:
renglon2 = ""
ww, hh = label.get_tamanio()
for palabra in palabras[2:]:
renglon2 += palabra + " "
label = JAMLabel(renglon2)
label.set_text(color=JAMG.get_blanco())
fuente, tamanio = JAMG.get_Font_fawn()
label.set_font_from_file(fuente, tamanio=30)
w, h = label.get_tamanio()
label.set_posicion(punto=(x - w / 2, y + hh - h))
self.add(label)
else:
label.set_posicion(punto=(x - w / 2, y))
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=(2, 30), duracion=3)
self.add(self.cronometro)
self.progress_reloj = ProgressBar(self.main)
self.add(self.progress_reloj)
self.decorativas = ImagenesDecorativas(self)
self.add(self.decorativas)
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()
def __init__(self, main):
pygame.sprite.OrderedUpdates.__init__(self)
imagen = os.path.join(G.IMAGENES, "Login", "fondo_selecciona.png")
imagen = pygame.transform.scale(pygame.image.load(imagen), (800, 570))
fuente, tamanio = JAMG.get_Font_fawn()
imagen_teclado = os.path.join(G.IMAGENES, "icono_teclado.jpg")
self.main = main
self.estado = None
self.usuario = {
'nombre': '',
'edad': '',
'escuela': '',
'clase': '',
'departamento': '',
'personaje': ''
}
self.jacinto = BotonUsuario()
imagenusuario = os.path.join(G.IMAGENES, "Login", "jacinto.png")
self.jacinto.set_imagen(origen=imagenusuario)
self.jacinto.connect(callback=self.select_personaje,
sonido_select=None)
self.jose = BotonUsuario()
imagenusuario = os.path.join(G.IMAGENES, "Login", "jose.png")
self.jose.set_imagen(origen=imagenusuario)
self.jose.connect(callback=self.select_personaje, sonido_select=None)
self.natalia = BotonUsuario()
imagenusuario = os.path.join(G.IMAGENES, "Login", "natalia.png")
self.natalia.set_imagen(origen=imagenusuario)
self.natalia.connect(callback=self.select_personaje,
sonido_select=None)
self.personajes = [self.jacinto, self.jose, self.natalia]
self.entrys = []
self.board = Board()
self.fondo = pygame.sprite.Sprite()
self.fondo.image = (imagen)
self.fondo.rect = self.fondo.image.get_rect()
self.add(self.fondo)
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=main.emit_volver, sonido_select=None)
self.add(salir)
# Ingresar nombre
self.label_nombre = JAMLabel("Nombre:")
self.label_nombre.set_text(color=(255, 255, 255, 255))
self.label_nombre.set_font_from_file(fuente, tamanio=30)
self.add(self.label_nombre)
self.entry_nombre = JAMButton("", None)
self.entrys.append(self.entry_nombre)
self.add(self.entry_nombre)
# Ingresar Edad
self.label_edad = JAMLabel("Edad:")
self.label_edad.set_text(color=(255, 255, 255, 255))
self.label_edad.set_font_from_file(fuente, tamanio=30)
self.add(self.label_edad)
self.entry_edad = JAMButton("", None)
self.entrys.append(self.entry_edad)
self.add(self.entry_edad)
# Ingresar escuela
self.label_escuela = JAMLabel("Escuela:")
self.label_escuela.set_text(color=(255, 255, 255, 255))
self.label_escuela.set_font_from_file(fuente, tamanio=30)
self.add(self.label_escuela)
self.entry_escuela = JAMButton("", None)
self.entrys.append(self.entry_escuela)
self.add(self.entry_escuela)
# Ingresar Clase
self.label_clase = JAMLabel("Clase:")
self.label_clase.set_text(color=(255, 255, 255, 255))
self.label_clase.set_font_from_file(fuente, tamanio=30)
self.add(self.label_clase)
self.entry_clase = JAMButton("", None)
self.entrys.append(self.entry_clase)
self.add(self.entry_clase)
# Ingresar departamento
self.label_departamento = JAMLabel("Departamento:")
self.label_departamento.set_text(color=(255, 255, 255, 255))
self.label_departamento.set_font_from_file(fuente, tamanio=30)
self.add(self.label_departamento)
self.entry_departamento = JAMButton("", None)
self.entrys.append(self.entry_departamento)
self.add(self.entry_departamento)
for boton in self.entrys:
boton.set_alineacion_label("izquierda")
boton.set_imagen(origen=imagen_teclado)
boton.set_font_from_file(fuente, tamanio=25)
boton.set_tamanios(tamanio=(300, 35),
grosorbor=1,
detalle=1,
espesor=1)
boton.connect(callback=None, sonido_select=None)
self.label_derecho = JAMLabel("Selecciona un Personaje:")
self.label_derecho.set_text(color=(255, 255, 255, 255))
self.label_derecho.set_font_from_file(fuente, tamanio=30)
self.add(self.label_derecho)
self.boton_crear = JAMButton("Crear", None)
self.boton_crear.set_font_from_file(fuente, tamanio=30)
self.boton_crear.set_tamanios(tamanio=(200, 40),
grosorbor=1,
detalle=1,
espesor=1)
self.boton_crear.set_colores(colorbas=(0, 157, 224, 255),
colorbor=(0, 157, 224, 255),
colorcara=(92, 193, 235, 255))
#self.boton_crear.set_colores(colorbas = (92,193,235,255),
# colorbor = (255,255,255,255), colorcara = (92,193,235,255))
self.boton_crear.set_text(color=(255, 255, 255, 255))
self.boton_crear.connect(callback=self.crear_usuario,
sonido_select=None)
self.add(self.boton_crear)
self.add(self.jacinto)
self.add(self.jose)
self.add(self.natalia)
self.entry_nombre.connect(callback=self.enter_nombre)
self.entry_edad.connect(callback=self.enter_edad)
self.entry_escuela.connect(callback=self.enter_escuela)
self.entry_clase.connect(callback=self.enter_clase)
self.entry_departamento.connect(callback=self.enter_departamento)
