def iniciar(self, pilas, tiempo, nombreDesafio):
marronOscuro = pilas.colores.Color(77, 38, 22)
self.nombreDesafio = str(int(nombreDesafio) + 1)
self.fondo = pilas.fondos.FondoMozaico("imagenes/fondo/fondoJuego.jpg")
self.textoDesafioTerminado = self.pilas.actores.Texto(
"Desafio " + str(nombreDesafio) + " terminado ",
magnitud=40,
fuente="datos/tipografia/anirb___.ttf")
self.tiempoEnElDesafio = self.pilas.actores.Texto(
"tiempo: " + tiempo.texto,
magnitud=40,
fuente="datos/tipografia/anirb___.ttf")
self.textoDesafioTerminado.y = 100
self.textoDesafioTerminado.color = marronOscuro
self.tiempoEnElDesafio.color = marronOscuro
self.botonMenuPrincipal = pilas.interfaz.Boton("ir al menu Principal")
self.botonMenuPrincipal.x = -150
self.botonMenuPrincipal.y = -150
self.botonMenuPrincipal.conectar(self.menuPrincipal)
self.botonSiguienteDesafio = pilas.interfaz.Boton("siguiente desafio")
self.botonSiguienteDesafio.x = 150
self.botonSiguienteDesafio.y = -150
self.botonSiguienteDesafio.conectar(self.siguienteDesafio)
# eventos:
self.pilas.eventos.pulsa_tecla_escape.conectar(self.menuPrincipal)
self.pilas.eventos.pulsa_tecla.conectar(self.interpretaTeclado)
mensaje = "¿Desafio superado!. (pulsa enter para ir al siguiente desafio o escape para ir al menu principal)"
leer(mensaje, False)
audio = Sonido("audio/logro.ogg")
audio.reproducir_esperando()
def efectoAlEliminar(self):
if self.pilas.datos.fichasFx == "on":
import os
from sonido import Sonido
nombre = "audio/" + self.nombre + "_eliminar.ogg"
if os.path.exists(nombre):
self.audio = Sonido(nombre)
self.audio.reproducir()
class DesafioSuperado(pilasengine.escenas.Escena):
def iniciar(self, pilas, tiempo, nombreDesafio):
marronOscuro = pilas.colores.Color(77, 38, 22)
self.nombreDesafio = str(int(nombreDesafio) + 1)
self.fondo = pilas.fondos.FondoMozaico("imagenes/fondo/fondoJuego.jpg")
self.textoDesafioTerminado = self.pilas.actores.Texto(
"Desafio " + str(nombreDesafio) + " terminado ",
magnitud=40,
fuente="datos/tipografia/anirb___.ttf")
self.tiempoEnElDesafio = self.pilas.actores.Texto(
"tiempo: " + tiempo.texto,
magnitud=40,
fuente="datos/tipografia/anirb___.ttf")
self.textoDesafioTerminado.y = 100
self.textoDesafioTerminado.color = marronOscuro
self.tiempoEnElDesafio.color = marronOscuro
self.botonMenuPrincipal = pilas.interfaz.Boton("ir al menu Principal")
self.botonMenuPrincipal.x = -150
self.botonMenuPrincipal.y = -150
self.botonMenuPrincipal.conectar(self.menuPrincipal)
self.botonSiguienteDesafio = pilas.interfaz.Boton("siguiente desafio")
self.botonSiguienteDesafio.x = 150
self.botonSiguienteDesafio.y = -150
self.botonSiguienteDesafio.conectar(self.siguienteDesafio)
# eventos:
self.pilas.eventos.pulsa_tecla_escape.conectar(self.menuPrincipal)
self.pilas.eventos.pulsa_tecla.conectar(self.interpretaTeclado)
mensaje = "¿Desafio superado!. (pulsa enter para ir al siguiente desafio o escape para ir al menu principal)"
leer(mensaje, False)
audio = Sonido("audio/logro.ogg")
audio.reproducir_esperando()
def siguienteDesafio(self):
self.sonido_activar = Sonido("audio/menu_enter.ogg")
self.sonido_activar.volumen = 0.3
self.sonido_activar.reproducir_esperando()
self.pilas.escenas.Desafio(pilas=self.pilas,
nombreDesafio=self.nombreDesafio)
def menuPrincipal(self, evento=None):
self.pilas.escenas.MenuPrincipal(self.pilas)
def interpretaTeclado(self, evento):
if evento.codigo == self.pilas.simbolos.SELECCION:
self.siguienteDesafio()
def __init__(self, pilas, tablero, tts, demora=30):
Actor.__init__(self, pilas, x=tablero.x, y=tablero.y)
self.imagen = "imagenes/cabezal.png"
self.tablero = tablero
self.columna=0
self.fila=0
self.control = pilas.escena_actual().control
self.decir=tts
self.activo = True
# sonidos:
self.sonido_mover = Sonido('audio/mover.ogg')
self.sonido_limite = Sonido('audio/limite.ogg')
self.x, self.y = self.tablero.posicion_de_celda(self.columna, self.fila)
self.escala = 2.3
def mostrarResultado(self,evento):
texto = self.pilas.actores.Texto("GANAN LAS ", y=330, x= -30,ancho= 800,magnitud=30)
texto.color = self.pilas.colores.Color(77, 38, 22)
mensaje = evento.motivo + ""
if evento.color == "blanco":
texto.texto = texto.texto + "BLANCAS"
mensaje += "GANAN LAS BLANCAS."
else:
texto.texto = texto.texto + "NEGRAS"
mensaje += "GANAN LAS NEGRAS."
audio = Sonido("audio/logro.ogg")
audio.reproducir_esperando()
self.decir(mensaje)
def iniciar(self, pilas, nombreDesafio):
musica = pilas.datos.musica
if musica is not None:
musica.detener_gradualmente(3)
self.fondo = pilas.fondos.FondoMozaico("imagenes/fondo/fondoJuego.jpg")
self.decir = tts
self.partida = Partida(pilas)
self.partida.definir_reglas("puzzle")
self.textoAyuda = TextoAyuda(self.pilas)
# se arma el reloj
self.reloj = Reloj(pilas, x=-150, y=300, incremental=True)
self.reloj.comenzar()
# armamos tablero:
self.tablero = Tablero(pilas, x=-400, y=-250, filas=8, columnas=8)
self.partida.definir_tablero(self.tablero)
# definimos la posicion inicial:
fichas = self.cargarDesafio("datos/desafios/" + nombreDesafio +
".chess")
self.nombreDesafio = nombreDesafio
self.partida.iniciar(posicionInicial=fichas)
self.cabezal = Cabezal(pilas, tablero=self.tablero, tts=tts)
# conexiones con eventos:
self.pilas.eventos.pulsa_tecla.conectar(self.interpreta_teclado)
self.pilas.eventos.click_de_mouse.conectar(self.click_mouse)
self.pilas.eventos.pulsa_tecla_escape.conectar(
self.activar_menu_principal)
# eventos de partida:
self.partida.eventoPreMueveFicha.conectar(self.mueveFicha)
self.partida.eventoFinalizar.conectar(self.finalizar)
# sonidos:
self.sonido_mover = Sonido('audio/mover-ficha.ogg')
self.historial = Historial(pilas,
ejex=300,
ejey=0,
cantidadDeJugadores=1)
self.historial.fijo = True
def iniciar(self, pilas):
self.fondo = pilas.fondos.FondoMozaico("imagenes/fondo/fondoJuego.jpg")
self.colorResaltado = pilas.colores.Color(128, 84, 66)
self.colorNormal = pilas.colores.Color(77, 38, 22)
self.menu_x = 0
self.menu_y = 0
self.fuente = "datos/tipografia/anirb___.ttf"
self.imagenFondo = "imagenes/fondo/boton.jpg"
self.distancia = 50
self.escala = 1
self.configuracion()
self.decir = tts
self.menu = Menu(pilas, x=self.menu_x, y=self.menu_y, opciones=self.listaOpciones(), fuente=self.fuente, color_normal=self.colorNormal, color_resaltado=self.colorResaltado , imagenFondo= self.imagenFondo, distancia=self.distancia, escala= self.escala)
self.menu.escala = self.escala
self.menu.seleccionaOpcion.conectar(self.seleccionarOpcion)
self.menu.activaOpcion.conectar(self.activarOpcion)
self.sonidoMover = Sonido("audio/menu_opcion.ogg")
self.sonidoAbrir = Sonido("audio/menu_abrir.ogg")
self.activar()
self.pilas.eventos.pulsa_tecla_escape.conectar(self.cuandoPulsaEscape)
def iniciar(self, pilas, datos=None):
colorResaltado = pilas.colores.Color(0, 0, 0)
colorNormal = pilas.colores.Color(255, 255, 255)
marronOscuro = pilas.colores.Color(77, 38, 22)
self.fondo = pilas.fondos.FondoMozaico("imagenes/fondo/fondoJuego.jpg")
self.decir = tts
self.datos=datos
opciones = self.listaOpciones()
self.menu = Menu(pilas,x = -300 ,y = 250, opciones = opciones,fuente= "datos/tipografia/anirb___.ttf", color_normal=colorNormal, color_resaltado=colorResaltado, imagenFondo= "imagenes/fondo/boton.jpg", escala=0.7, distancia= 60 )
self.menu.escala = 0.5
self.menu.seleccionaOpcion.conectar(self.seleccionarItem)
self.menu.activaOpcion.conectar(self.activarOpcion)
self.decir(u"Modo juego: pulse las flechas para elegir un modo de juego.", False)
self.sonidoMover = Sonido("audio/menu_opcion.ogg")
self.sonidoAbrir = Sonido("audio/menu_abrir.ogg")
self.sonidoAbrir.reproducir()
self.texto = pilas.actores.Texto("", x= 170 ,y=25, ancho=500 , magnitud= 19, fuente= "datos/tipografia/al.ttf")
self.texto.color = marronOscuro
self.pilas.eventos.pulsa_tecla_escape.conectar(self.activar_menu_principal)
def main():
#variables
sound = Sonido()
temp = Temperatura()
matriz_led = Led()
while True:
if (sound.evento_detectado()):
datos = temp.datos_sensor() #Me cargo los datos procesados
mensaje = 'Temperatura' + str(
datos['temperatura']
) + 'Humedad ' + str(
datos['humedad']
) #Me quedo con el último registro ambiental del archivo de la oficina en la que estoy
matriz_led.mostrar_mensaje(
msg=mensaje) #Mando el mensaje a mostrar
event = sg.PopupYesNo('Terminar',
auto_close=True,
auto_close_duration=2)
if (event == 'Yes'):
break
def __init__(self,
pilas,
x=0,
y=0,
opciones=[],
rutaImagenes=None,
fuente=None,
color_normal=colores.gris,
color_resaltado=colores.blanco):
Actor.__init__(self, pilas, x=x, y=y)
self.opciones_como_actores = []
self.iconos_de_opciones = []
self.imagen = "invisible.png"
self.rutaImagenes = rutaImagenes
self.escalaImagenes = 0.05
self.decir = tts
# sonidos:
self.sonido_abrir = Sonido("audio/menu_abrir.ogg")
self.sonido_mover = Sonido("audio/menu_opcion.ogg")
self.sonido_activar = Sonido("audio/menu_enter.ogg")
self.sonido_activar.volumen = 0.3
self._verificar_opciones(opciones)
self.crear_opciones(opciones, fuente, color_normal, color_resaltado)
self.opciones = opciones
self.seleccionar_primer_opcion()
self.opcion_actual = 0
self.activar()
class ModoJuego(pilasengine.escenas.Escena):
def iniciar(self, pilas, datos=None):
colorResaltado = pilas.colores.Color(0, 0, 0)
colorNormal = pilas.colores.Color(255, 255, 255)
marronOscuro = pilas.colores.Color(77, 38, 22)
self.fondo = pilas.fondos.FondoMozaico("imagenes/fondo/fondoJuego.jpg")
self.decir = tts
self.datos=datos
opciones = self.listaOpciones()
self.menu = Menu(pilas,x = -300 ,y = 250, opciones = opciones,fuente= "datos/tipografia/anirb___.ttf", color_normal=colorNormal, color_resaltado=colorResaltado, imagenFondo= "imagenes/fondo/boton.jpg", escala=0.7, distancia= 60 )
self.menu.escala = 0.5
self.menu.seleccionaOpcion.conectar(self.seleccionarItem)
self.menu.activaOpcion.conectar(self.activarOpcion)
self.decir(u"Modo juego: pulse las flechas para elegir un modo de juego.", False)
self.sonidoMover = Sonido("audio/menu_opcion.ogg")
self.sonidoAbrir = Sonido("audio/menu_abrir.ogg")
self.sonidoAbrir.reproducir()
self.texto = pilas.actores.Texto("", x= 170 ,y=25, ancho=500 , magnitud= 19, fuente= "datos/tipografia/al.ttf")
self.texto.color = marronOscuro
self.pilas.eventos.pulsa_tecla_escape.conectar(self.activar_menu_principal)
def activar_menu_principal(self, evento):
self.pilas.escenas.MenuPrincipal(pilas=self.pilas)
def seleccionarItem(self, evento):
file = open("datos/regla/" + (self.menu.opciones [self.menu.opcion_actual]) [0] + ".regla", "r")
info = file.read()
file.close()
self.sonidoMover.reproducir()
self.decir(evento.texto)
self.texto.texto = info
self.decir(info, False)
def activarOpcion(self, evento):
self.sonido_activar = Sonido("audio/menu_enter.ogg")
self.sonido_activar.volumen = 0.3
self.sonido_activar.reproducir()
def listaOpciones(self):
lista = []
for f in listdir("datos/regla"):
lista.append(f[:-6])
lista.sort()
return map(lambda x: (x, self.configurarModo, x), lista)
def activar(self):
self.decir(u"Modos de juegos disponibles: pulse las flechas para elegir uno, pulse enter para ver como se juega o pulsa escape para regresar al menu anterior.", False)
def cuandoPulsaEscape(self, evento):
self.pilas.escenas.MenuPrincipal(pilas=self.pilas)
def configurarModo(self , modo):
self.pilas.datos['modoJuego'] = modo
self.pilas.escenas.PantallaJuego(pilas=self.pilas)
def iniciar(self, pilas, datos=None):
musica = pilas.datos.musica
if musica is not None:
musica.detener_gradualmente(3)
self.fondo = pilas.fondos.FondoMozaico("imagenes/fondo/fondoJuego.jpg")
self.decir = tts
self.datos = datos
self.partida = Partida(pilas, self.datos)
self.partida.definir_reglas(pilas.datos.modoJuego)
self.textoAyuda = TextoAyuda(self.pilas)
# armamos tablero:
self.tablero = Tablero(pilas, x=- 400 ,y=-250)
self.partida.definir_tablero(self.tablero)
self.partida.iniciar()
self.cabezal = Cabezal(pilas, tablero=self.tablero, tts=tts)
# conexiones con eventos:
self.pilas.eventos.pulsa_tecla.conectar(self.interpreta_teclado)
self.pilas.eventos.click_de_mouse.conectar(self.click_mouse)
self.pilas.eventos.pulsa_tecla_escape.conectar(self.activar_menu_principal)
# eventos de juego:
self.partida.eventoPreMueveFicha.conectar(self.mueveFicha)
self.partida.eventoFinalizar.conectar(self.mostrarResultado)
# sonidos:
self.sonido_mover = Sonido('audio/mover-ficha.ogg')
self.historial = Historial(pilas, ejex=320, ejey=0)
self.historial.fijo = True
#
self.botonReiniciar = pilas.interfaz.Boton("Nueva Partida")
self.botonReiniciar.x = 400
self.botonReiniciar.y = -300
self.botonReiniciar.conectar(self.nuevaPartida)
self.botonReiniciar.fijo = True
class EscenaMenu(pilasengine.escenas.Escena):
def configuracion(self):
"""Este metodo se debe sobreescribir si alguna variable de la configuracion se debe modificar"""
pass
def iniciar(self, pilas):
self.fondo = pilas.fondos.FondoMozaico("imagenes/fondo/fondoJuego.jpg")
self.colorResaltado = pilas.colores.Color(128, 84, 66)
self.colorNormal = pilas.colores.Color(77, 38, 22)
self.menu_x = 0
self.menu_y = 0
self.fuente = "datos/tipografia/anirb___.ttf"
self.imagenFondo = "imagenes/fondo/boton.jpg"
self.distancia = 50
self.escala = 1
self.configuracion()
self.decir = tts
self.menu = Menu(pilas, x=self.menu_x, y=self.menu_y, opciones=self.listaOpciones(), fuente=self.fuente, color_normal=self.colorNormal, color_resaltado=self.colorResaltado , imagenFondo= self.imagenFondo, distancia=self.distancia, escala= self.escala)
self.menu.escala = self.escala
self.menu.seleccionaOpcion.conectar(self.seleccionarOpcion)
self.menu.activaOpcion.conectar(self.activarOpcion)
self.sonidoMover = Sonido("audio/menu_opcion.ogg")
self.sonidoAbrir = Sonido("audio/menu_abrir.ogg")
self.activar()
self.pilas.eventos.pulsa_tecla_escape.conectar(self.cuandoPulsaEscape)
def cuandoPulsaEscape(self, evento):
self.pilas.escenas.MenuPrincipal(pilas=self.pilas)
def activar(self):
self.decir(u"menú principal: pulse las flechas para navegar por el menú.", False)
self.sonidoAbrir.reproducir()
def seleccionarOpcion(self, evento):
self.sonidoMover.reproducir()
self.decir(evento.texto)
def activarOpcion(self, evento):
self.sonido_activar = Sonido("audio/menu_enter.ogg")
self.sonido_activar.volumen = 0.3
self.sonido_activar.reproducir()
def listaOpciones(self):
return ["Salir", self.salir]
def salir(self):
exit()
def iniciar(self, pilas, datos=None):
musica = pilas.datos.musica
if musica is not None:
musica.reproducir(repetir=True)
self.pilas.eventos.pulsa_tecla_escape.conectar(self.cuandoPulsaEscape)
marronClaro = pilas.colores.Color(128, 84, 66)
marronOscuro = pilas.colores.Color(77, 38, 22)
self.fondo = pilas.fondos.FondoMozaico("imagenes/fondo/fondoMenu.jpg")
self.decir = tts
self.datos = datos
if datos is None:
opciones = [('Jugar contra la maquina', self.jugar),
(u"Desafíos", self.desafios),
(u"Modos de juego para 2 jugadores", self.modoJuego),
(u'Configuracion', self.configurar),
(u"Conectarse a un servidor", self.conectarse),
(u"Establecerse como servidor", self.levantarServidor),
(u"Creditos", self.creditos), ('Salir', self.salir)]
else:
opciones = [
('Jugar contra la maquina', self.jugar),
(u'Continuar Con la partida', self.continuarConPartida),
(u"Desafíos", self.desafios),
(u"Modos de juego para 2 jugadores", self.modoJuego),
(u'Configuracion', self.configurar),
(u"Conectarse a un servidor", self.conectarse),
(u"Establecerse como servidor", self.levantarServidor),
(u"Creditos", self.creditos), ('Salir', self.salir)
]
self.menu = Menu(pilas,
y=170,
opciones=opciones,
fuente="datos/tipografia/anirb___.ttf",
color_normal=marronOscuro,
color_resaltado=marronClaro)
self.menu.seleccionaOpcion.conectar(self.seleccionarItem)
self.menu.activaOpcion.conectar(self.activarOpcion)
self.decir(
u"menú principal: pulse las flechas para navegar por el menú.",
False)
self.sonidoMover = Sonido("audio/menu_opcion.ogg")
self.sonidoAbrir = Sonido("audio/menu_abrir.ogg")
self.sonidoCerrar = Sonido("audio/menu_cerrar.ogg")
self.sonidoAbrir.reproducir()
def __init__(self, *args, **kwargs):
Reglas.__init__(self, *args, **kwargs)
self.sonido_revote = Sonido("audio/boing.ogg")
self.fichaRey = "rey"
def siguienteDesafio(self):
self.sonido_activar = Sonido("audio/menu_enter.ogg")
self.sonido_activar.volumen = 0.3
self.sonido_activar.reproducir_esperando()
self.pilas.escenas.Desafio(pilas=self.pilas,
nombreDesafio=self.nombreDesafio)
class MenuPrincipal(pilasengine.escenas.Escena):
def iniciar(self, pilas, datos=None):
musica = pilas.datos.musica
if musica is not None:
musica.reproducir(repetir=True)
self.pilas.eventos.pulsa_tecla_escape.conectar(self.cuandoPulsaEscape)
marronClaro = pilas.colores.Color(128, 84, 66)
marronOscuro = pilas.colores.Color(77, 38, 22)
self.fondo = pilas.fondos.FondoMozaico("imagenes/fondo/fondoMenu.jpg")
self.decir = tts
self.datos = datos
if datos is None:
opciones = [('Jugar contra la maquina', self.jugar),
(u"Desafíos", self.desafios),
(u"Modos de juego para 2 jugadores", self.modoJuego),
(u'Configuracion', self.configurar),
(u"Conectarse a un servidor", self.conectarse),
(u"Establecerse como servidor", self.levantarServidor),
(u"Creditos", self.creditos), ('Salir', self.salir)]
else:
opciones = [
('Jugar contra la maquina', self.jugar),
(u'Continuar Con la partida', self.continuarConPartida),
(u"Desafíos", self.desafios),
(u"Modos de juego para 2 jugadores", self.modoJuego),
(u'Configuracion', self.configurar),
(u"Conectarse a un servidor", self.conectarse),
(u"Establecerse como servidor", self.levantarServidor),
(u"Creditos", self.creditos), ('Salir', self.salir)
]
self.menu = Menu(pilas,
y=170,
opciones=opciones,
fuente="datos/tipografia/anirb___.ttf",
color_normal=marronOscuro,
color_resaltado=marronClaro)
self.menu.seleccionaOpcion.conectar(self.seleccionarItem)
self.menu.activaOpcion.conectar(self.activarOpcion)
self.decir(
u"menú principal: pulse las flechas para navegar por el menú.",
False)
self.sonidoMover = Sonido("audio/menu_opcion.ogg")
self.sonidoAbrir = Sonido("audio/menu_abrir.ogg")
self.sonidoCerrar = Sonido("audio/menu_cerrar.ogg")
self.sonidoAbrir.reproducir()
def cuandoPulsaEscape(self, evento):
if self.datos:
self.sonidoCerrar.reproducir()
self.continuarConPartida()
def seleccionarItem(self, evento):
self.sonidoMover.reproducir()
self.decir(evento.texto)
def activarOpcion(self, evento):
self.sonido_activar = Sonido("audio/menu_enter.ogg")
self.sonido_activar.volumen = 0.3
self.sonido_activar.reproducir()
def jugar(self):
self.pilas.datos['modoJuego'] = "ajedrezIa"
self.pilas.escenas.ElegirColor(self.pilas)
def continuarConPartida(self):
self.pilas.escenas.PantallaJuego(pilas=self.pilas, datos=self.datos)
def desafios(self):
self.pilas.escenas.MenuDesafios(pilas=self.pilas)
#self.pilas.escenas.Desafio(pilas=self.pilas, nombreDesafio='2')
def conectarse(self):
self.pilas.avisar("No se pudo conectar...\n\n")
#self.pilas.escenas.ConectarseAlServidor(pilas=self.pilas)
def levantarServidor(self):
self.pilas.avisar("error: el servidor no se pudo levantar.\n\n")
print("servidor no disponible.")
def modoJuego(self):
self.pilas.escenas.ModoJuego(pilas=self.pilas)
def creditos(self):
self.pilas.escenas.Creditos(pilas=self.pilas)
def configurar(self):
self.pilas.escenas.Configurar(self.pilas)
def salir(self):
exit()
class PantallaJuego(pilasengine.escenas.Escena):
def iniciar(self, pilas, datos=None):
musica = pilas.datos.musica
if musica is not None:
musica.detener_gradualmente(3)
self.fondo = pilas.fondos.FondoMozaico("imagenes/fondo/fondoJuego.jpg")
self.decir = tts
self.datos = datos
self.partida = Partida(pilas, self.datos)
self.partida.definir_reglas(pilas.datos.modoJuego)
self.textoAyuda = TextoAyuda(self.pilas)
# armamos tablero:
self.tablero = Tablero(pilas, x=- 400 ,y=-250)
self.partida.definir_tablero(self.tablero)
self.partida.iniciar()
self.cabezal = Cabezal(pilas, tablero=self.tablero, tts=tts)
# conexiones con eventos:
self.pilas.eventos.pulsa_tecla.conectar(self.interpreta_teclado)
self.pilas.eventos.click_de_mouse.conectar(self.click_mouse)
self.pilas.eventos.pulsa_tecla_escape.conectar(self.activar_menu_principal)
# eventos de juego:
self.partida.eventoPreMueveFicha.conectar(self.mueveFicha)
self.partida.eventoFinalizar.conectar(self.mostrarResultado)
# sonidos:
self.sonido_mover = Sonido('audio/mover-ficha.ogg')
self.historial = Historial(pilas, ejex=320, ejey=0)
self.historial.fijo = True
#
self.botonReiniciar = pilas.interfaz.Boton("Nueva Partida")
self.botonReiniciar.x = 400
self.botonReiniciar.y = -300
self.botonReiniciar.conectar(self.nuevaPartida)
self.botonReiniciar.fijo = True
def activar_menu_principal(self, evento):
datos=None
if self.partida.activa:
datos=self.partida.datos
self.pilas.escenas.MenuPrincipal(pilas=self.pilas, datos=datos)
def mueveFicha(self, evento):
self.sonido_mover.reproducir()
if evento.fichaEliminada:
self.decir(str(evento.ficha) +" por "+ str(evento.fichaEliminada) +" de "+ repr(evento.celdaDestino))
#print("fuera de juego", fichaEliminada.nombre, fichaEliminada.color)
self.historial.agregar(repr(evento.ficha) + "x" + repr(evento.celdaDestino))
else:
self.decir(str(evento.ficha)+" mueve a: "+repr(evento.celdaDestino))
self.historial.agregar(repr(evento.ficha) + repr(evento.celdaDestino))
def click_mouse(self, evento):
x = (int(evento.x) + (self.tablero.distancia / 2) + int(self.pilas.camara.x)) - self.tablero.x
y = (int(evento.y) + (self.tablero.distancia / 2) + int(self.pilas.camara.y)) - self.tablero.y
columna = x / self.tablero.distancia
fila = y / self.tablero.distancia
if(evento.boton == 1):
self.cabezal.mover(columna=columna, fila=fila)
#elf.cabezal.seleccionar()
self.partida.seleccionar_celda(columna=self.cabezal.columna, fila=self.cabezal.fila)
if(evento.boton == 2):
ficha = self.tablero.obtenerFicha(columna=columna,fila=fila)
if ficha is not None:
self.textoAyuda.infoDePieza(ficha.nombre,x,y)
def interpreta_teclado(self, evento):
if evento.codigo == "a" or evento.codigo == self.pilas.simbolos.IZQUIERDA:
self.cabezal.mover_izquierda()
if self.tablero.columnas > 8 and abs(self.cabezal.x - self.camara.x) > 400 and self.cabezal.x - self.camara.x < 399:
self.pilas.camara.x = [self.cabezal.x + 400]
if evento.codigo == "d" or evento.codigo == self.pilas.simbolos.DERECHA:
self.cabezal.mover_derecha()
if self.tablero.columnas > 8 and self.cabezal.x - self.camara.x > -400 and self.cabezal.x - self.camara.x > 399 :
self.pilas.camara.x = [self.cabezal.x - 400]
if evento.codigo == "s" or evento.codigo == self.pilas.simbolos.ABAJO:
self.cabezal.mover_abajo()
if self.tablero.filas > 8 and abs(self.cabezal.y - self.camara.y) > 200:
self.pilas.camara.y = [self.cabezal.y + 200]
if evento.codigo == "w" or evento.codigo == self.pilas.simbolos.ARRIBA:
self.cabezal.mover_arriba()
if self.tablero.filas > 8 and abs(self.cabezal.y - self.camara.y) > 200:
self.pilas.camara.y = [self.cabezal.y - 200]
if evento.codigo == self.pilas.simbolos.SELECCION:
self.partida.seleccionar_celda(columna=self.cabezal.columna, fila=self.cabezal.fila)
if evento.codigo == "g":
self.historial.subir()
if evento.codigo == "h":
self.historial.bajar()
if evento.codigo == "n":
self.nuevaPartida()
if evento.codigo == "F1":
ficha = self.tablero.obtenerFicha(columna=self.cabezal.columna, fila=self.cabezal.fila)
if ficha is not None:
info = self.textoAyuda.infoDePieza(ficha.nombre ,
self.cabezal.x +30,self.cabezal.y)
self.decir(info)
def nuevaPartida(self):
self.audio = Sonido("audio/acomodar_tablero.ogg")
self.audio.reproducir()
self.pilas.escenas.PantallaJuego(pilas=self.pilas, datos=self.datos)
def mostrarResultado(self,evento):
texto = self.pilas.actores.Texto("GANAN LAS ", y=330, x= -30,ancho= 800,magnitud=30)
texto.color = self.pilas.colores.Color(77, 38, 22)
mensaje = evento.motivo + ""
if evento.color == "blanco":
texto.texto = texto.texto + "BLANCAS"
mensaje += "GANAN LAS BLANCAS."
else:
texto.texto = texto.texto + "NEGRAS"
mensaje += "GANAN LAS NEGRAS."
audio = Sonido("audio/logro.ogg")
audio.reproducir_esperando()
self.decir(mensaje)
def nuevaPartida(self):
self.audio = Sonido("audio/acomodar_tablero.ogg")
self.audio.reproducir()
self.pilas.escenas.PantallaJuego(pilas=self.pilas, datos=self.datos)
def __init__(self, *args, **kwargs):
Reglas.__init__(self, *args, **kwargs)
self.sonido_revote = Sonido("audio/boing.ogg")
self.sonido_boom = Sonido("audio/boom.wav")
self.sonido_boom.volumen = 0.6
def activarOpcion(self, evento):
self.sonido_activar = Sonido("audio/menu_enter.ogg")
self.sonido_activar.volumen = 0.3
self.sonido_activar.reproducir()
def __init__(self, *args, **kwargs):
Reglas.__init__(self, True, *args, **kwargs)
self.personalizado = True
self.sonido_revote = Sonido("audio/boing.ogg")
#!/usr/bin/python
# -*- coding: utf-8 -*-
import time
from matriz import Matriz
from sonido import Sonido
from temperatura import Temperatura
# Conexión de los sensores en sus respectivos pines
# Matriz --> vcc: 2, gnd: 6, din: 19, cs: 24, clk: 23
# Sonido --> a0: 7, gnd: 9, vc: 3, d0: 15
# Temperatura --> vcc: 1, sda: 11, clk: 14
# Activamos los sensores que vamos a usar
# matriz = Matriz(numero_matrices=2, ancho=16)
matriz = Matriz()
sonido = Sonido()
temperatura = Temperatura()
def acciones():
""""Obtiene los datos del sensor y lo muestra en la matriz"""
#obtiene datos del sensor
temp_data = temperatura.datos_sensor()
#la escribe con un formato
temp_formateada = 'Temperatura = {0:0.1f}°0C Humedad = {1:0.1f}%'.format(
temp_data['temperatura'], temp_data['humedad'])
#muestra el mensaje en la matriz
matriz.mostrar_mensaje(temp_formateada, delay=0.08, font=2)
class MenuConImagen(Actor):
"""Un actor que puede mostrar una lista de opciones a seleccionar."""
def __init__(self,
pilas,
x=0,
y=0,
opciones=[],
rutaImagenes=None,
fuente=None,
color_normal=colores.gris,
color_resaltado=colores.blanco):
Actor.__init__(self, pilas, x=x, y=y)
self.opciones_como_actores = []
self.iconos_de_opciones = []
self.imagen = "invisible.png"
self.rutaImagenes = rutaImagenes
self.escalaImagenes = 0.05
self.decir = tts
# sonidos:
self.sonido_abrir = Sonido("audio/menu_abrir.ogg")
self.sonido_mover = Sonido("audio/menu_opcion.ogg")
self.sonido_activar = Sonido("audio/menu_enter.ogg")
self.sonido_activar.volumen = 0.3
self._verificar_opciones(opciones)
self.crear_opciones(opciones, fuente, color_normal, color_resaltado)
self.opciones = opciones
self.seleccionar_primer_opcion()
self.opcion_actual = 0
self.activar()
def activar(self):
"""Se ejecuta para activar el comportamiento del menú."""
self.pilas.escena_actual().mueve_mouse.conectar(
self.cuando_mueve_el_mouse)
self.pilas.escena_actual().click_de_mouse.conectar(
self.cuando_hace_click_con_el_mouse)
self.pilas.eventos.pulsa_tecla.conectar(self.interpreta_teclado)
self.sonido_abrir.reproducir()
def desactivar(self):
"""Deshabilita toda la funcionalidad del menú."""
self.pilas.escena_actual().mueve_mouse.desconectar(
self.cuando_mueve_el_mouse)
self.pilas.escena_actual().click_de_mouse.desconectar(
self.cuando_hace_click_con_el_mouse)
self.pilas.eventos.pulsa_tecla.desconectar(self.interpreta_teclado)
def crear_opciones(self, opciones, fuente, color_normal, color_resaltado):
"""Genera un actor por cada opcion del menu.
:param opciones: Una lista con todas las opciones que tendrá el menú.
"""
for indice, opcion in enumerate(opciones):
y = self.y - indice * 40
if len(opcion) == 2:
texto, funcion, argumentos = opcion[0], opcion[1], opcion[
2:] #No debería de aceptar argumentos
else:
if isinstance(opcion[2], list):
texto, funcion, argumentos = opcion[1], opcion[2][
0], opcion[2][1:]
icono = self.pilas.actores.Actor(x=-120, y=y)
icono.imagen = opcion[0]
print("..." + opcion[0])
self.iconos_de_opciones.append(icono)
else:
texto, funcion, argumentos = opcion[0], opcion[1], opcion[
2:]
opciones = OpcionConImagen(self.pilas,
texto,
x=0,
y=y,
funcion_a_invocar=funcion,
argumentos=argumentos,
fuente=fuente,
color_normal=color_normal,
color_resaltado=color_resaltado,
imagen=self.rutaImagenes + texto +
".png",
escala=self.escalaImagenes)
self.opciones_como_actores.append(opciones)
def seleccionar_primer_opcion(self):
"""Destaca la primer opción del menú."""
if self.opciones_como_actores:
self.opciones_como_actores[0].resaltar()
try:
self.iconos_de_opciones[0].escala = [self.escala * 2], .2
except:
pass
def _verificar_opciones(self, opciones):
"""Se asegura de que la lista este bien definida.
:param opciones: La lista de opciones a inspeccionar.
"""
for x in opciones:
if not isinstance(x, tuple) or len(x) < 2:
raise Exception(
"Opciones incorrectas, cada opcion tiene que ser una tupla."
)
def interpreta_teclado(self, evento):
"""Comportamiento al pulsar tecla"""
if evento.codigo == self.pilas.simbolos.SELECCION:
self.sonido_activar.reproducir()
self.seleccionar_opcion_actual()
elif evento.codigo == self.pilas.simbolos.ABAJO:
self.sonido_mover.reproducir()
self.mover_cursor(1)
elif evento.codigo == self.pilas.simbolos.ARRIBA:
self.sonido_mover.reproducir()
self.mover_cursor(-1)
def seleccionar_opcion_actual(self):
"""Se ejecuta para activar y lanzar el item actual."""
opcion = self.opciones_como_actores[self.opcion_actual]
opcion.seleccionar()
def mover_cursor(self, delta):
"""Realiza un movimiento del cursor que selecciona opciones.
:param delta: El movimiento a realizar (+1 es avanzar y -1 retroceder).
"""
# Deja como no-seleccionada la opcion actual.
self._deshabilitar_opcion_actual()
# Se asegura que las opciones esten entre 0 y 'cantidad de opciones'.
self.opcion_actual += delta
self.opcion_actual %= len(self.opciones_como_actores)
# si hay funcion de lectura lee la opcion:
if self.decir:
self.decir(self.opciones_como_actores[self.opcion_actual].texto)
# Selecciona la opcion nueva.
self.opciones_como_actores[self.opcion_actual].resaltar()
try:
self.iconos_de_opciones[self.opcion_actual].escala = [
self.escala * 2
], .3
except:
pass
def __setattr__(self, atributo, valor):
# Intenta propagar la accion a los actores del grupo.
try:
for x in self.opciones_como_actores:
setattr(x, atributo, valor)
for x in self.iconos_de_opciones:
setattr(x, atributo, valor)
except AttributeError:
pass
Actor.__setattr__(self, atributo, valor)
def cuando_mueve_el_mouse(self, evento):
"""Permite cambiar la opcion actual moviendo el mouse. Retorna True si el mouse esta sobre alguna opcion.
:param evento: El evento que representa el movimiento del mouse.
"""
for indice, opcion in enumerate(self.opciones_como_actores):
if opcion.colisiona_con_un_punto(evento.x, evento.y):
if indice != self.opcion_actual:
self._deshabilitar_opcion_actual()
self.opcion_actual = indice
self.opciones_como_actores[indice].resaltar()
try:
self.iconos_de_opciones[self.opcion_actual].escala = [
self.escala * 2
], .3
except:
pass
return True
def _deshabilitar_opcion_actual(self):
"""Le quita el foco o resaltado a la opción del menú actual."""
self.opciones_como_actores[self.opcion_actual].resaltar(False)
try:
self.iconos_de_opciones[self.opcion_actual].escala = [self.escala
], .3
except:
pass
def cuando_hace_click_con_el_mouse(self, evento):
"""Se ejecuta cuando se hace click con el mouse.
:param evento: objeto que representa el evento click de mouse.
"""
if self.cuando_mueve_el_mouse(evento):
self.seleccionar_opcion_actual()
from matriz import Matriz
from sonido import Sonido
from temperatura import Temperatura
import time
# Conexión de los sensores en sus respectivos pines
# Matriz --> vcc: 2, gnd: 6, din: 19, cs: 24, clk: 23
# Sonido --> a0: 7, gnd: 9, vc: 3, d0: 15
# Temperatura --> vcc: 1, sda: 11, clk: 14
# Activamos los sensores que vamos a usar
# matriz = Matriz(numero_matrices=2, ancho=16)
matriz = Matriz(numero_matrices=2, ancho=16)
sonido = Sonido()
temperatura = Temperatura()
def acciones():
print("Sonido Detectado!")
temp_data = temperatura.datos_sensor()
temp_formateada = 'Temperatura = {0:0.1f}°C Humedad = {1:0.1f}%'.format(temp_data['temperatura'],
temp_data['humedad'])
matriz.mostrar_mensaje(temp_formateada, delay=0.08, font=2)
def mostrar():
time.sleep(0.1)
print('ejecutar mostrar')
sonido.evento_detectado(acciones)
class ReglasAjedrezTradicional(Reglas):
def __init__(self, *args, **kwargs):
Reglas.__init__(self, *args, **kwargs)
self.sonido_revote = Sonido("audio/boing.ogg")
self.fichaRey = "rey"
def seleccionar_celda(self, columna, fila):
"""Selecciona una celda.
solo se puede seleccionar celdas que tienen fichas.
si ya hay una seleccionada realiza un movimiento
"""
if self.celda_seleccionada is None:
# si no hay ninguna celda seleccionada:
celda = self.partida.tablero.obtener_celda(columna, fila)
if celda.tiene_ficha():
turno_actual = self.turno_actual()
if celda.ficha.color == turno_actual:
# seleccionamos la celda:
self.celda_seleccionada = celda
self.celda_seleccionada.seleccionar()
celda.ficha.seleccionar()
self.decir(
str(self.celda_seleccionada.ficha) + " seleccionado")
else:
self.decir("es turno del " + turno_actual)
else:
# si ya hay celda seleccionada:
if self.celda_seleccionada.columna == columna and self.celda_seleccionada.fila == fila:
# si selecciona 2 veces la misma celda la deselecciona.
self.decir(
str(self.celda_seleccionada.ficha) + " deseleccionado")
self._deseleccionarCelda()
else:
# si selecciona otra celda realiza el movimiento:
self.mover_ficha(columna, fila)
def mover_ficha(self, columna, fila):
ficha = self.celda_seleccionada.ficha
celda = self.partida.tablero.obtener_celda(columna, fila)
# verificamos si la celda tiene ficha:
if celda.tiene_ficha():
# si tiene ficha verificamos que no sea del mismo color:
celdaVerificada = ficha.color != celda.ficha.color
else:
celdaVerificada = True
if ficha.puede_mover(celda) and celdaVerificada:
# puede realizar el movimiento:
self.partida.registrar_movimiento(
ficha=self.celda_seleccionada.ficha,
fichaEliminada=celda.ficha,
celdaOrigen=self.celda_seleccionada,
celdaDestino=celda)
# verificamos si enroca:
if ficha.nombre == "rey" and (celda_origen.fila in [0, 7]
and abs(celda_origen.columna -
celda_destino.columna) == 2):
# enroca:
if celda_destino.columna == 6:
#enroque corto:
self.acomodarTorreDeEnroque(largo=False)
else:
# enroque largo:
self.acomodarTorreDeEnroque(largo=True)
if celda.ficha is not None:
celda.ficha.efectoAlEliminar()
self.celda_seleccionada.liberar()
# valida si se comio el rey para finalizar la partida:
if celda.ficha is not None and celda.ficha.nombre == self.fichaRey:
self.partida.finalizar(motivo="jacke mate",
color=self.colorOpuesto(
celda.ficha.color))
self.partida.tablero.posicionar(ficha, columna=columna, fila=fila)
self.pasar_turno()
self._deseleccionarCelda()
self.partida.finalizaMovimiento(celda)
else:
# no puede realizar el movimiento:
self._deseleccionarCelda()
self.movimiento_imposible()
def colorOpuesto(self, color):
if color == "blanco":
return "negro"
else:
return "blanco"
def _deseleccionarCelda(self):
"""deselecciona una celda seleccionada:
precondici�n: debe haber una celda seleccionada.
la propiedad: celda_seleccionada no debe ser None"""
self.celda_seleccionada.deseleccionar()
self.celda_seleccionada = None
def movimiento_imposible(self):
"""metodo que se ejecuta cuando un jugador realiza un movimiento imposible"""
self.sonido_revote.reproducir()
self.decir("movimiento imposible")
def acomodarTorreDeEnroque(self, largo=True):
print("enroca")
if not largo:
#enroque corto:
c = self.partida.tablero.obtener_celda(7, 0)
self.partida.tablero.posicionar(c.ficha, columna=5, fila=0)
c.liberar()
else:
# enroque largo:
c = self.partida.tablero.obtener_celda(0, 0)
self.partida.tablero.posicionar(c.ficha, columna=3, fila=0)
c.liberar()
class Desafio(pilasengine.escenas.Escena):
def iniciar(self, pilas, nombreDesafio):
musica = pilas.datos.musica
if musica is not None:
musica.detener_gradualmente(3)
self.fondo = pilas.fondos.FondoMozaico("imagenes/fondo/fondoJuego.jpg")
self.decir = tts
self.partida = Partida(pilas)
self.partida.definir_reglas("puzzle")
self.textoAyuda = TextoAyuda(self.pilas)
# se arma el reloj
self.reloj = Reloj(pilas, x=-150, y=300, incremental=True)
self.reloj.comenzar()
# armamos tablero:
self.tablero = Tablero(pilas, x=-400, y=-250, filas=8, columnas=8)
self.partida.definir_tablero(self.tablero)
# definimos la posicion inicial:
fichas = self.cargarDesafio("datos/desafios/" + nombreDesafio +
".chess")
self.nombreDesafio = nombreDesafio
self.partida.iniciar(posicionInicial=fichas)
self.cabezal = Cabezal(pilas, tablero=self.tablero, tts=tts)
# conexiones con eventos:
self.pilas.eventos.pulsa_tecla.conectar(self.interpreta_teclado)
self.pilas.eventos.click_de_mouse.conectar(self.click_mouse)
self.pilas.eventos.pulsa_tecla_escape.conectar(
self.activar_menu_principal)
# eventos de partida:
self.partida.eventoPreMueveFicha.conectar(self.mueveFicha)
self.partida.eventoFinalizar.conectar(self.finalizar)
# sonidos:
self.sonido_mover = Sonido('audio/mover-ficha.ogg')
self.historial = Historial(pilas,
ejex=300,
ejey=0,
cantidadDeJugadores=1)
self.historial.fijo = True
def activar_menu_principal(self, evento):
self.pilas.escenas.MenuPrincipal(pilas=self.pilas)
def mueveFicha(self, evento):
self.sonido_mover.reproducir()
if evento.fichaEliminada:
self.decir(
str(evento.ficha) + " por " + str(evento.fichaEliminada) +
" de " + repr(evento.celdaDestino))
self.historial.agregar(
repr(evento.ficha) + "x" + repr(evento.celdaDestino))
else:
self.decir(
str(evento.ficha) + " mueve a: " + repr(evento.celdaDestino))
self.historial.agregar(
repr(evento.ficha) + repr(evento.celdaDestino))
def click_mouse(self, evento):
x = int(evento.x) - (self.tablero.x -
self.tablero.distancia / 2) + self.pilas.camara.x
y = int(evento.y) - (self.tablero.y -
self.tablero.distancia / 2) + self.pilas.camara.y
columna = x / self.tablero.distancia
fila = y / self.tablero.distancia
if (evento.boton == 1):
self.cabezal.mover(columna=columna, fila=fila)
self.partida.seleccionar_celda(columna=self.cabezal.columna,
fila=self.cabezal.fila)
if (evento.boton == 2):
ficha = self.tablero.obtenerFicha(columna=columna, fila=fila)
if ficha is not None:
self.textoAyuda.infoDePieza(ficha.nombre, x, y)
def interpreta_teclado(self, evento):
if evento.codigo == "a" or evento.codigo == self.pilas.simbolos.IZQUIERDA:
self.cabezal.mover_izquierda()
if evento.codigo == "d" or evento.codigo == self.pilas.simbolos.DERECHA:
self.cabezal.mover_derecha()
if evento.codigo == "s" or evento.codigo == self.pilas.simbolos.ABAJO:
self.cabezal.mover_abajo()
if evento.codigo == "w" or evento.codigo == self.pilas.simbolos.ARRIBA:
self.cabezal.mover_arriba()
if evento.codigo == "n":
self.pilas.escenas.Desafio(pilas=self.pilas,
nombreDesafio=self.nombreDesafio)
if evento.codigo == self.pilas.simbolos.SELECCION:
self.partida.seleccionar_celda(columna=self.cabezal.columna,
fila=self.cabezal.fila)
if evento.codigo == "F1":
ficha = self.tablero.obtenerFicha(columna=self.cabezal.columna,
fila=self.cabezal.fila)
if ficha is not None:
self.textoAyuda.infoDePieza(ficha.nombre, self.cabezal.x + 30,
self.cabezal.y)
def cargarDesafio(self, rutaDeArchivo):
file = open(rutaDeArchivo, "r")
info = file.read()
file.close()
info = info.split("\n")
lista = []
for x in info:
if x != "":
x = x.split(" ")
x.append(int(x[2][1]) - 1)
x[2] = ord(x[2][0]) - 97
lista.append(tuple(x))
return lista
def finalizar(self, evento):
if evento.motivo == "superado":
if self.nombreDesafio == '9':
self.pilas.escenas.GanasteLosDesafios(self.pilas)
else:
self.pilas.escenas.DesafioSuperado(self.pilas,
self.reloj.texto,
self.nombreDesafio)
class ReglasAjedrezMinado(Reglas):
def __init__(self, *args, **kwargs):
Reglas.__init__(self, *args, **kwargs)
self.sonido_revote = Sonido("audio/boing.ogg")
self.sonido_boom = Sonido("audio/boom.wav")
self.sonido_boom.volumen = 0.6
def posIniciar(self):
self.colocarMinaZonaBlanca()
self.colocarMinaZonaNegra()
def seleccionar_celda(self, columna, fila):
"""Selecciona una celda.
solo se puede seleccionar celdas que tienen fichas.
si ya hay una seleccionada realiza un movimiento
"""
if self.celda_seleccionada is None:
# si no hay ninguna celda seleccionada:
celda = self.partida.tablero.obtener_celda(columna, fila)
if celda.tiene_ficha():
turno_actual = self.turno_actual()
if celda.ficha.color == turno_actual:
# seleccionamos la celda:
self.celda_seleccionada = celda
self.celda_seleccionada.seleccionar()
self.decir(
str(self.celda_seleccionada.ficha) + " seleccionado")
else:
self.decir("es turno del " + turno_actual)
else:
# si ya hay celda seleccionada:
if self.celda_seleccionada.columna == columna and self.celda_seleccionada.fila == fila:
# si selecciona 2 veces la misma celda la deselecciona.
self.decir(
str(self.celda_seleccionada.ficha) + " deseleccionado")
self._deseleccionarCelda()
else:
# si selecciona otra celda realiza el movimiento:
self.mover_ficha(columna, fila)
def mover_ficha(self, columna, fila):
ficha = self.celda_seleccionada.ficha
celda = self.partida.tablero.obtener_celda(columna, fila)
# verificamos si la celda tiene ficha:
if celda.tiene_ficha():
# si tiene ficha verificamos que no sea del mismo color:
celdaVerificada = ficha.color != celda.ficha.color
else:
celdaVerificada = True
if ficha.puede_mover(celda) and celdaVerificada:
# puede realizar el movimiento:
self.partida.registrar_movimiento(
ficha=self.celda_seleccionada.ficha,
fichaEliminada=celda.ficha,
celdaOrigen=self.celda_seleccionada,
celdaDestino=celda)
self.celda_seleccionada.liberar()
# valida si se comio el rey para finalizar la partida:
if celda.ficha is not None and celda.ficha.nombre == "rey":
self.partida.finalizar(motivo="jacke mate",
color=self.colorOpuesto(
celda.ficha.color))
self.partida.tablero.posicionar(ficha, columna=columna, fila=fila)
if (celda.fila == self.minaZonaBlanca[0]
and celda.columna == self.minaZonaBlanca[1]):
self.explotar(celda)
self.colocarMinaZonaBlanca()
if (celda.fila == self.minaZonaNegra[0]
and celda.columna == self.minaZonaNegra[1]):
self.explotar(celda)
self.colocarMinaZonaNegra()
self.pasar_turno()
self._deseleccionarCelda()
self.partida.finalizaMovimiento(celda)
else:
# no puede realizar el movimiento:
self._deseleccionarCelda()
self.movimiento_imposible()
def _deseleccionarCelda(self):
"""deselecciona una celda seleccionada:
precondici�n: debe haber una celda seleccionada.
la propiedad: celda_seleccionada no debe ser None"""
self.celda_seleccionada.deseleccionar()
self.celda_seleccionada = None
def movimiento_imposible(self):
"""metodo que se ejecuta cuando un jugador realiza un movimiento imposible"""
self.sonido_revote.reproducir()
self.decir("movimiento imposible")
def colocarMinaZonaBlanca(self):
bomba = (randint(0, (self.partida.tablero.columnas / 2) - 1),
randint(0, self.partida.tablero.filas - 1))
while (self.partida.tablero.obtener_celda(bomba[1], bomba[0]).ficha
is not None):
bomba = (randint(0, (self.partida.tablero.columnas / 2) - 1),
randint(0, self.partida.tablero.filas - 1))
print(chr(97 + bomba[1]) + str(bomba[0] + 1))
self.minaZonaBlanca = bomba
def colocarMinaZonaNegra(self):
bomba = (randint((self.partida.tablero.columnas / 2) + 1,
self.partida.tablero.columnas - 1),
randint(0, self.partida.tablero.filas - 1))
while (self.partida.tablero.obtener_celda(bomba[1], bomba[0]).ficha
is not None):
bomba = (randint((self.partida.tablero.columnas / 2) + 1,
self.partida.tablero.columnas - 1),
randint(0, self.partida.tablero.filas - 1))
print(chr(97 + bomba[1]) + str(bomba[0] + 1))
self.minaZonaNegra = bomba
def explotar(self, celda):
if celda.ficha.nombre == 'rey':
self.partida.finalizar(motivo="jacke mate",
color=self.colorOpuesto(celda.ficha.color))
self.sonido_boom.reproducir()
self.grilla = self.partida.pilas.imagenes.cargar_grilla(
"imagenes/animaciones/ExplosionGrande.png", 12)
p = self.partida.pilas.actores.Animacion(self.grilla,
False,
x=celda.x,
y=celda.y,
velocidad=15)
x = self.partida.pilas.camara.x
y = self.partida.pilas.camara.y
self.partida.pilas.camara.vibrar(intensidad=3, tiempo=0.3)
self.partida.pilas.tareas.agregar(0.35, self.acomodarCamara, x=x, y=y)
celdas = self.partida.tablero.obteneer_celdas_lindantes(
celda.fila, celda.columna)
for x in celdas:
if x.ficha is not None and x.ficha.nombre != 'peon':
if x.ficha.nombre == 'rey':
self.partida.finalizar(motivo="jacke mate",
color=self.colorOpuesto(
x.ficha.color))
self.partida.tablero.elimiraPieza(x)
self.partida.tablero.elimiraPieza(celda)
def acomodarCamara(self, x, y):
self.partida.pilas.camara.x = x
self.partida.pilas.camara.y = y
def colorOpuesto(self, color):
if color == "blanco":
return "negro"
else:
return "blanco"
#!/usr/bin/python
# -*- coding: utf-8 -*-
import time
from matriz import Matriz
from sonido import Sonido
from temperatura import Temperatura
# Conexión de los sensores en sus respectivos pines
# Matriz --> vcc: 2, gnd: 6, din: 19, cs: 24, clk: 23
# Sonido --> a0: 7, gnd: 9, vc: 3, d0: 15
# Temperatura --> vcc: 1, sda: 11, clk: 14
# Activamos los sensores que vamos a usar
matriz = Matriz(numero_matrices=2, ancho=16)
sonido = Sonido()
temperatura = Temperatura()
def acciones():
print("Sonido Detectado!")
temp_data = temperatura.datos_sensor()
temp_formateada = 'Temperatura = {0:0.1f}°C Humedad = {1:0.1f}%'.format(
temp_data['temperatura'], temp_data['humedad'])
matriz.mostrar_mensaje(temp_formateada, delay=0.08, font=2)
def periodica():
fileOfTemp = open('ultimo_log_temperatura.json', 'r+')
while True:
class PuzzleAjedrez(Reglas):
def __init__(self, *args, **kwargs):
Reglas.__init__(self, True, *args, **kwargs)
self.personalizado = True
self.sonido_revote = Sonido("audio/boing.ogg")
def posIniciar(self, *args, **kwargs):
self.fichasActivas = self.partida.pool.fichasActivas()
def seleccionar_celda(self, columna, fila):
"""Selecciona una celda.
solo se puede seleccionar celdas que tienen fichas.
si ya hay una seleccionada realiza un movimiento
"""
if self.celda_seleccionada is None:
# si no hay ninguna celda seleccionada:
celda = self.partida.tablero.obtener_celda(columna, fila)
if celda.tiene_ficha():
# seleccionamos la celda:
self.celda_seleccionada = celda
self.celda_seleccionada.seleccionar()
self.decir(
str(self.celda_seleccionada.ficha) + " seleccionado")
else:
# si ya hay celda seleccionada:
if self.celda_seleccionada.columna == columna and self.celda_seleccionada.fila == fila:
# si selecciona 2 veces la misma celda la deselecciona.
self.decir(
str(self.celda_seleccionada.ficha) + " deseleccionado")
self._deseleccionarCelda()
else:
# si selecciona otra celda realiza el movimiento:
self.mover_ficha(columna, fila)
def mover_ficha(self, columna, fila):
ficha = self.celda_seleccionada.ficha
celda = self.partida.tablero.obtener_celda(columna, fila)
if ficha.puede_mover(celda) and celda.tiene_ficha():
# puede realizar el movimiento:
self.partida.registrar_movimiento(
ficha=self.celda_seleccionada.ficha,
fichaEliminada=celda.ficha,
celdaOrigen=self.celda_seleccionada,
celdaDestino=celda)
self.celda_seleccionada.liberar()
self.partida.tablero.posicionar(ficha, columna=columna, fila=fila)
self._deseleccionarCelda()
# valida si queda una ficha o no tiene posibilidad de comer. para finalizar el puzzgle.
self.fichasActivas = self.partida.pool.fichasActivas()
if self.fichasActivas == 1:
self.partida.finalizar(motivo="superado")
else:
# no puede realizar el movimiento:
self._deseleccionarCelda()
self.movimiento_imposible()
def _deseleccionarCelda(self):
"""deselecciona una celda seleccionada:
precondici�n: debe haber una celda seleccionada.
la propiedad: celda_seleccionada no debe ser None"""
self.celda_seleccionada.deseleccionar()
self.celda_seleccionada = None
def movimiento_imposible(self):
"""metodo que se ejecuta cuando un jugador realiza un movimiento imposible"""
self.sonido_revote.reproducir()
self.decir("movimiento imposible")
