def enviar_reporte(self, id, final):
if (final != ""):
self.conexion = Conexion()
fecha = time.strftime("%y-%m-%d")
self.conexion.enviar_registro(self.query_envio(),
(final, fecha, self.puntuacion))
self.final = True
def __init__(self, ctrl):
self.controlador = ctrl
self.mensaje_encriptado = ""
self.mensaje_desencriptado = ""
self.consulta_query = "SELECT * FROM Palabra;"
self.conexion = Conexion()
self.palabras = self.conexion.enviar_consulta(self.consulta_query)
self.fondo = "view/img/fondos/Espera-espectral.jpg"
self.abecedario = [
'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'
]
self.mensajes()
self.construir()
self.vida_actuales = 2
self.puntuacion = 0
self.dificultad = 1
self.tiempoJuego = 0
class Departamento_service:
"""
Servicio de eventos para el Departamento, su estructura va formada como scripting
"""
def __init__(self):
"""
Constructor fachada
"""
self.conexion = Conexion()
def ver_todos(self):
"""
Se obtienen todas las Departamento de la base de datos
@return: Lista de departamentos en la base de datos
@rtype: <class 'list'>
"""
query = "SELECT * FROM departamento;"
consulta = self.conexion.enviar_consulta(query)
return consulta
def __init__(self):
"""
Constructor fachada
"""
self.conexion = Conexion()
class Estudiante_service:
"""
Servicio de eventos para el estudiante, su estructura va formada como scripting
"""
def __init__(self):
"""
Constructor fachada
"""
self.conexion = Conexion()
def guardar(self, estudiante):
"""
Guarda el estudiante actual en la base de datos
@param estudiante: estudiante y sus respectivos datos
@type: <class= 'Estudiante'>
@return: guardado satisfactorio
@rtype: boolean
"""
profesor = estudiante.consejero
if (not profesor):
profesor = "NULL"
query = """INSERT INTO estudiante(
id_estudiante,
nombre1,
nombre2,
apellido1,
apellido2,
edad,
lugar_nacimiento,
ciudad_residencia,
direccion_residencia,
semestre,
consejero,
contra,
usuario
) VALUES ({}, '{}', '{}', '{}', '{}', {}, {}, {}, '{}', {}, {}, '{}', '{}')""".format(
estudiante.num, estudiante.nombre1, estudiante.nombre2,
estudiante.apellido1, estudiante.apellido2, estudiante.edad,
estudiante.lugar_nacimiento, estudiante.ciudad_residencia,
estudiante.direccion_residencia, estudiante.semestre, profesor,
estudiante.contra, estudiante.usuario)
return (not self.conexion.enviar_registro(query))
def ver_todos(self):
"""
Retornara todos los datos del estudiante almacenados en la base de datos
@return: Datos de la base de datos
@rtype: [tuple]
"""
query = "SELECT * FROM estudiante;"
return self.conexion.enviar_consulta(query)
def eliminar(self, estudiante):
"""
Elimina un Estudiante de la base de datos
@param estudiante: id del estudiante a eliminar
@type estudiante: int
@return: True si se hizo correctamente
@rtype: boolean
"""
query = "DELETE FROM estudiante WHERE id_estudiante={}".format(
estudiante)
return (not self.conexion.enviar_registro(query))
class Profesor_service:
"""
Clase enfocada en la construccion de los eventos del servicio del profesor
"""
def __init__(self):
"""
Constructor enfocado en el diseccionamiento de los servicios
"""
self.conexion = Conexion()
def ver_todos(self, facultad=0):
"""
Servicio/Metodo enfoca en ver todos por facultad
@return: lista de todos los profesores en una facultad que estan en la base de datos
@rtype: <class= 'list'>
"""
if (facultad == 0):
query = "SELECT * FROM profesor;"
consulta = self.conexion.enviar_consulta(query)
return consulta
else:
query = "SELECT * FROM profesor WHERE facultad = '{}';".format(facultad)
consulta = self.conexion.enviar_consulta(query)
return consulta
def ver_todas_facultades(self):
"""
Servicio/Metodo enfocado en la muestra de todas las facultades en la base de datos
@return: lista de todas las facultades de la base de datos
@rtype: <class= 'list'>
"""
query = "SELECT * FROM departamento;"
consulta = self.conexion.enviar_consulta(query)
return consulta
def guardar(self, profesor):
"""
Servicio/Metodo enfocado en el guardado de los datos del profesor
@param profesor: Datos del profesor a introducir
@type profesor: <class= 'Profesor'>
@return: Retrna true si los datos se almacenaron correctamente
@rtype: boolean
"""
es_visitante = "FALSE"
if (profesor.es_is_visitante() == "si"):
es_visitante = "TRUE"
query=""
f1 = f2 = "NULL"
if (profesor.inicio_nombramiento):
f1 = "{}-{}-{}".format(profesor.inicio_nombramiento.year, profesor.inicio_nombramiento.month, profesor.inicio_nombramiento.day)
f2 = "{}-{}-{}".format(profesor.fin_nombramiento.year, profesor.fin_nombramiento.month, profesor.fin_nombramiento.day)
query = """
INSERT INTO profesor(id_profesor, nombre1, nombre2, apellido1, apellido2, edad, lugar_nacimiento, ciudad_residencia, direccion_residencia, es_visitante, titulo, contrato, inicio_nombramiento, fin_nombramiento, facultad, contra, usuario) VALUES ({}, '{}', '{}', '{}', '{}', {}, {}, {}, '{}', {}, '{}', '{}', '{}', '{}', {}, '{}', '{}');
""".format(profesor.num,
profesor.nombre1,
profesor.nombre2,
profesor.apellido1,
profesor.apellido2,
profesor.edad,
profesor.lugar_nacimiento,
profesor.ciudad_residencia,
profesor.direccion_residencia,
es_visitante,
profesor.titulo,
profesor.contrato,
f1,
f2,
profesor.departamento,
profesor.contra,
profesor.usuario)
else:
query = """
INSERT INTO profesor(id_profesor, nombre1, nombre2, apellido1, apellido2, edad, lugar_nacimiento, ciudad_residencia, direccion_residencia, es_visitante, titulo, contrato, inicio_nombramiento, fin_nombramiento, facultad, contra, usuario) VALUES ({}, '{}', '{}', '{}', '{}', {}, {}, {}, '{}', {}, '{}', '{}', {}, {}, {}, '{}', '{}');
""".format(profesor.num,
profesor.nombre1,
profesor.nombre2,
profesor.apellido1,
profesor.apellido2,
profesor.edad,
profesor.lugar_nacimiento,
profesor.ciudad_residencia,
profesor.direccion_residencia,
es_visitante,
profesor.titulo,
profesor.contrato,
f1,
f2,
profesor.departamento,
profesor.contra,
profesor.usuario)
return (not self.conexion.enviar_registro(query))
def eliminar(self, profesor):
"""
Elimina un Profesor de la base de datos
@param profesor: id del profesor a eliminar
@type profesor: int
@return: True si se hizo correctamente
@rtype: boolean
"""
query = "DELETE FROM profesor WHERE id_profesor={}".format(profesor)
return (not self.conexion.enviar_registro(query))
def __init__(self):
"""
Constructor enfocado en el diseccionamiento de los servicios
"""
self.conexion = Conexion()
class Terminar:
def __init__(self):
self.puntuacion = 0
self.color_fondo = (255, 255, 255)
self.construir()
self.desactivarTextBox()
self.final = False
def construir(self):
self.titulo = Titulo("KACH!", 320, 50, 70, 1, (126, 81, 9))
self.titulo_terminado = Titulo("Juego Terminado!", 320, 100, 40, 3,
(14, 98, 81))
self.titulo_puntaje = Titulo("Su puntaje es:", 320, 150, 30, 4,
(36, 32, 163))
self.lblPuntuacion = Titulo("0", 300, 260, 180, 2, (0, 0, 0))
self.lblinstrucciones = Titulo("Presione <Enter> para continuar", 320,
440, 30, 4, (126, 81, 9))
self.lblindicacion = Titulo("Ingrese Alias:", 320, 360, 25, 3,
(14, 98, 81))
self.input = TextBox((220, 380, 200, 30),
command=self.enviar_reporte,
clear_on_enter=True,
inactive_on_enter=False)
def activarTextBox(self):
self.input.active = True
def desactivarTextBox(self):
self.input.active = False
def pintar(self, screen):
screen.fill(self.color_fondo)
self.titulo.pintar(screen)
self.titulo_terminado.pintar(screen)
self.titulo_puntaje.pintar(screen)
self.lblPuntuacion.pintar(screen)
self.lblindicacion.pintar(screen)
self.lblinstrucciones.pintar(screen)
self.input.update()
self.input.draw(screen)
def eventos(self, evento):
self.input.get_event(evento)
def enviar_reporte(self, id, final):
if (final != ""):
self.conexion = Conexion()
fecha = time.strftime("%y-%m-%d")
self.conexion.enviar_registro(self.query_envio(),
(final, fecha, self.puntuacion))
self.final = True
def modificar_puntuacion(self, puntuacion):
self.puntuacion = puntuacion
self.lblPuntuacion.modificarTexto(str(puntuacion))
def getFinal(self):
return self.final
def reiniciar(self):
self.final = False
def query_envio(self):
return (
"INSERT INTO Jugador(nombre,fecha,puntuacion) VALUES (%s, %s, %s);"
)
class Juego(object):
"""Clase que carga todo lo referente al juego"""
def __init__(self, ctrl):
self.controlador = ctrl
self.mensaje_encriptado = ""
self.mensaje_desencriptado = ""
self.consulta_query = "SELECT * FROM Palabra;"
self.conexion = Conexion()
self.palabras = self.conexion.enviar_consulta(self.consulta_query)
self.fondo = "view/img/fondos/Espera-espectral.jpg"
self.abecedario = [
'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'
]
self.mensajes()
self.construir()
self.vida_actuales = 2
self.puntuacion = 0
self.dificultad = 1
self.tiempoJuego = 0
# 1 -> Facil
# 2 -> medio
# 3 -> Dificil
# Para implementar
def mensajes(self):
self.titulos = {
"e_invertir": "Encriptar Invertir",
"d_invertir": "Desencriptar Invertir",
"e_atbash": "Encriptar Atbash",
"d_atbash": "Desencriptar Atbash",
"e_polibi": "Encriptar Polibi",
"d_polibi": "Desencriptar Polibi",
"e_cesar": "Encriptar Cesar",
"d_cesar": "Desencriptar Cesar"
}
def construir(self):
"""
Metodo que va a generar la construccion grafica del juego
"""
self.fondo = Imagen(self.fondo, (0, 0))
self.fondo.cambiarEscala(0.5)
self.titulo = Titulo("KACH!", 120, 450, 70, 2, (36, 32, 163))
self.lblNivel = Titulo("Nivel 1", 550, 30, 40, 2, (36, 32, 163))
self.cuadro = Boton("")
self.cuadro.modificarPosicion(10, 50)
self.cuadro.modificarTamano(620, 200)
self.cuadro.modificarPosicionTexto(30, 27)
self.cuadro.modificarColor1(234, 234, 216)
self.cuadro.modificarColorLetra1(21, 67, 96)
self.cuadro.modificarColor2(234, 234, 216)
self.cuadro.modificarColorLetra2(21, 67, 96)
self.cuadro.modificarColor3(234, 234, 216)
self.cuadro.modificarColorLetra3(21, 67, 96)
self.cuadro.modificarEvento(0)
self.cuadro_corazon = Boton("Vidas:")
self.cuadro_corazon.modificarPosicion(10, 360)
self.cuadro_corazon.modificarTamano(180, 40)
self.cuadro_corazon.modificarPosicionTexto(30, 20)
self.cuadro_corazon.modificarColor1(255, 255, 255)
self.cuadro_corazon.modificarColorLetra1(21, 67, 96)
self.cuadro_corazon.modificarColor2(255, 255, 255)
self.cuadro_corazon.modificarColorLetra2(21, 67, 96)
self.cuadro_corazon.modificarColor3(255, 255, 255)
self.cuadro_corazon.modificarColorLetra3(21, 67, 96)
self.cuadro_corazon.modificarEvento(0)
self.cuadro_tiempo = Boton("Tiempo:")
self.cuadro_tiempo.modificarPosicion(10, 10)
self.cuadro_tiempo.modificarTamano(180, 40)
self.cuadro_tiempo.modificarPosicionTexto(30, 20)
self.cuadro_tiempo.modificarColor1(255, 255, 255)
self.cuadro_tiempo.modificarColorLetra1(21, 67, 96)
self.cuadro_tiempo.modificarColor2(255, 255, 255)
self.cuadro_tiempo.modificarColorLetra2(21, 67, 96)
self.cuadro_tiempo.modificarColor3(255, 255, 255)
self.cuadro_tiempo.modificarColorLetra3(21, 67, 96)
self.cuadro_tiempo.modificarEvento(0)
self.lblTiempo = Titulo("30", 120, 32, 20, 2, (20, 90, 50))
self.cuadro_Puntuacion = Boton("Puntuacion:")
self.cuadro_Puntuacion.modificarPosicion(450, 360)
self.cuadro_Puntuacion.modificarTamano(180, 40)
self.cuadro_Puntuacion.modificarPosicionTexto(50, 20)
self.cuadro_Puntuacion.modificarColor1(255, 255, 255)
self.cuadro_Puntuacion.modificarColorLetra1(21, 67, 96)
self.cuadro_Puntuacion.modificarColor2(255, 255, 255)
self.cuadro_Puntuacion.modificarColorLetra2(21, 67, 96)
self.cuadro_Puntuacion.modificarColor3(255, 255, 255)
self.cuadro_Puntuacion.modificarColorLetra3(21, 67, 96)
self.cuadro_Puntuacion.modificarEvento(0)
self.lblPuntuacion = Titulo("0", 590, 380, 20, 2, (36, 32, 163))
img_vidas = "view/img/corazon.jpg"
self.vida1 = Imagen(img_vidas, (65, 360))
self.vida1.cambiarEscala(0.25)
self.vida2 = Imagen(img_vidas, (105, 360))
self.vida2.cambiarEscala(0.25)
self.vida3 = Imagen(img_vidas, (145, 360))
self.vida3.cambiarEscala(0.25)
self.btnOpcion1 = Boton("Opcion1")
self.btnOpcion1.modificarPosicion(30, 280)
self.btnOpcion1.modificarTamano(140, 50)
self.btnOpcion1.modificarPosicionTexto(60, 27)
self.btnOpcion1.modificarColor1(234, 234, 216)
self.btnOpcion1.modificarColorLetra1(21, 67, 96)
self.btnOpcion1.modificarColor2(209, 210, 179)
self.btnOpcion1.modificarColorLetra2(21, 67, 96)
self.btnOpcion1.modificarColor3(91, 202, 213)
self.btnOpcion1.modificarColorLetra3(21, 67, 96)
self.btnOpcion1.modificarEvento(8)
self.btnOpcion2 = Boton("Opcion2")
self.btnOpcion2.modificarPosicion(180, 280)
self.btnOpcion2.modificarTamano(140, 50)
self.btnOpcion2.modificarPosicionTexto(60, 27)
self.btnOpcion2.modificarColor1(234, 234, 216)
self.btnOpcion2.modificarColorLetra1(21, 67, 96)
self.btnOpcion2.modificarColor2(209, 210, 179)
self.btnOpcion2.modificarColorLetra2(21, 67, 96)
self.btnOpcion2.modificarColor3(91, 202, 213)
self.btnOpcion2.modificarColorLetra3(21, 67, 96)
self.btnOpcion2.modificarEvento(9)
self.btnOpcion3 = Boton("Opcion3")
self.btnOpcion3.modificarPosicion(330, 280)
self.btnOpcion3.modificarTamano(140, 50)
self.btnOpcion3.modificarPosicionTexto(60, 27)
self.btnOpcion3.modificarColor1(234, 234, 216)
self.btnOpcion3.modificarColorLetra1(21, 67, 96)
self.btnOpcion3.modificarColor2(209, 210, 179)
self.btnOpcion3.modificarColorLetra2(21, 67, 96)
self.btnOpcion3.modificarColor3(91, 202, 213)
self.btnOpcion3.modificarColorLetra3(21, 67, 96)
self.btnOpcion3.modificarEvento(10)
self.btnOpcion4 = Boton("Opcion4")
self.btnOpcion4.modificarPosicion(480, 280)
self.btnOpcion4.modificarTamano(140, 50)
self.btnOpcion4.modificarPosicionTexto(60, 27)
self.btnOpcion4.modificarColor1(234, 234, 216)
self.btnOpcion4.modificarColorLetra1(21, 67, 96)
self.btnOpcion4.modificarColor2(209, 210, 179)
self.btnOpcion4.modificarColorLetra2(21, 67, 96)
self.btnOpcion4.modificarColor3(91, 202, 213)
self.btnOpcion4.modificarColorLetra3(21, 67, 96)
self.btnOpcion4.modificarEvento(11)
self.btnInicio = Boton("Salir")
self.btnInicio.modificarPosicion(460, 420)
self.btnInicio.modificarTamano(160, 50)
self.btnInicio.modificarPosicionTexto(30, 27)
self.btnInicio.modificarColor1(234, 234, 216)
self.btnInicio.modificarColorLetra1(21, 67, 96)
self.btnInicio.modificarColor2(209, 210, 179)
self.btnInicio.modificarColorLetra2(21, 67, 96)
self.btnInicio.modificarColor3(91, 202, 213)
self.btnInicio.modificarColorLetra3(21, 67, 96)
self.btnInicio.modificarEvento(6)
self.pregunta = Titulo("", 320, 60, 17, 3, (36, 32, 163))
self.pregunta1 = Titulo("", 320, 90, 17, 3, (36, 32, 163))
self.pregunta2 = Titulo("", 320, 120, 17, 3, (36, 32, 163))
self.pregunta3 = Titulo("", 320, 150, 17, 3, (36, 32, 163))
self.pregunta4 = Titulo("", 320, 180, 17, 3, (36, 32, 163))
self.pregunta5 = Titulo("", 320, 210, 17, 3, (36, 32, 163))
self.pregunta6 = Titulo("", 320, 240, 17, 3, (36, 32, 163))
#Enviar al controlador
self.controlador.enviarEventoBoton(self.btnOpcion1)
self.controlador.enviarEventoBoton(self.btnOpcion2)
self.controlador.enviarEventoBoton(self.btnOpcion3)
self.controlador.enviarEventoBoton(self.btnOpcion4)
self.controlador.enviarEventoBoton(self.btnInicio)
def activar_botones(self):
self.btnOpcion1.modificarActivo(True)
self.btnOpcion2.modificarActivo(True)
self.btnOpcion3.modificarActivo(True)
self.btnOpcion4.modificarActivo(True)
self.btnInicio.modificarActivo(True)
def desactivar_botones(self):
self.btnOpcion1.modificarActivo(False)
self.btnOpcion2.modificarActivo(False)
self.btnOpcion3.modificarActivo(False)
self.btnOpcion4.modificarActivo(False)
self.btnInicio.modificarActivo(False)
def reiniciar(self):
#self.seleccionar_pregunta()
self.vida_actuales = 2
self.puntuacion = 0
self.dificultad = 1
def num_aleatorio(self, ini, fin):
return random.randint(ini, fin)
def pintar(self, screen, tiempo):
"""
Pinta en pantalla la parte grafica
@param screen: Pantalla en la que se va a pintar
@type screen: Surface
"""
self.fondo.ponerImagen(screen)
self.titulo.pintar(screen)
self.lblNivel.pintar(screen)
self.cuadro.pintar(screen)
self.cuadro_corazon.pintar(screen)
self.cuadro_tiempo.pintar(screen)
self.cuadro_Puntuacion.pintar(screen)
self.tiempoJuego = tiempo
if (tiempo <= 3):
self.lblTiempo.modificarColor((148, 49, 38))
elif (tiempo <= 6):
self.lblTiempo.modificarColor((229, 175, 32))
else:
self.lblTiempo.modificarColor((91, 229, 69))
self.lblTiempo.modificarTexto(str(tiempo))
self.lblTiempo.pintar(screen)
self.lblPuntuacion.modificarTexto(str(self.puntuacion))
self.lblPuntuacion.pintar(screen)
if (self.vida_actuales == 2):
self.vida1.ponerImagen(screen)
self.vida2.ponerImagen(screen)
self.vida3.ponerImagen(screen)
elif (self.vida_actuales == 1):
self.vida1.ponerImagen(screen)
self.vida2.ponerImagen(screen)
elif (self.vida_actuales == 0):
self.vida1.ponerImagen(screen)
else:
#GAME OVER
pass
self.pregunta.pintar(screen)
self.pregunta1.pintar(screen)
self.pregunta2.pintar(screen)
self.pregunta3.pintar(screen)
self.pregunta4.pintar(screen)
self.pregunta5.pintar(screen)
self.pregunta6.pintar(screen)
self.btnOpcion1.pintar(screen)
self.btnOpcion2.pintar(screen)
self.btnOpcion3.pintar(screen)
self.btnOpcion4.pintar(screen)
self.btnInicio.pintar(screen)
def seleccionar_pregunta(self):
self.pregunta.modificarTexto("")
self.pregunta1.modificarTexto("")
self.pregunta2.modificarTexto("")
self.pregunta3.modificarTexto("")
self.pregunta4.modificarTexto("")
self.pregunta5.modificarTexto("")
self.pregunta6.modificarTexto("")
self.btnOpcion1.modificarString("")
self.btnOpcion2.modificarString("")
self.btnOpcion3.modificarString("")
self.btnOpcion4.modificarString("")
tipo = self.num_aleatorio(1, 2)
#decidira si es encriptar o desencriptar
#1 -> encriptar
#2 -> Desencriptar
if (tipo == 1):
tipo = self.num_aleatorio(0, len(self.palabras) - 1)
(_, self.mensaje_desencriptado) = self.palabras[tipo]
tipo = self.num_aleatorio(1, 4)
self.pregunta1.modificarTexto("La Palabra a Encriptar es:")
if (tipo == 1):
#Invertida
self.pregunta.modificarTexto(self.titulos["e_invertir"])
self.mensaje_encriptado = self.lista_to_str_espaciado(
self.invetirOracion(self.mensaje_desencriptado))
self.pregunta2.modificarTexto(self.mensaje_desencriptado)
self.pregunta3.modificarTexto(
"Seleccione la encriptacion correcta")
tipo = self.num_aleatorio(1, 4) #Pone el correcto
if (tipo == 1):
self.btnOpcion1.modificarString(self.mensaje_encriptado)
self.btnOpcion2.modificarString(
self.lista_to_str_espaciado(
self.invetirOracion(
self.palabras[self.num_aleatorio(
0,
len(self.palabras) - 1)][1])))
self.btnOpcion3.modificarString(
self.lista_to_str_espaciado(
self.invetirOracion(
self.palabras[self.num_aleatorio(
0,
len(self.palabras) - 1)][1])))
self.btnOpcion4.modificarString(
self.lista_to_str_espaciado(
self.invetirOracion(
self.palabras[self.num_aleatorio(
0,
len(self.palabras) - 1)][1])))
elif (tipo == 2):
self.btnOpcion2.modificarString(self.mensaje_encriptado)
self.btnOpcion1.modificarString(
self.lista_to_str_espaciado(
self.invetirOracion(
self.palabras[self.num_aleatorio(
0,
len(self.palabras) - 1)][1])))
self.btnOpcion3.modificarString(
self.lista_to_str_espaciado(
self.invetirOracion(
self.palabras[self.num_aleatorio(
0,
len(self.palabras) - 1)][1])))
self.btnOpcion4.modificarString(
self.lista_to_str_espaciado(
self.invetirOracion(
self.palabras[self.num_aleatorio(
0,
len(self.palabras) - 1)][1])))
elif (tipo == 3):
self.btnOpcion3.modificarString(self.mensaje_encriptado)
self.btnOpcion2.modificarString(
self.lista_to_str_espaciado(
self.invetirOracion(
self.palabras[self.num_aleatorio(
0,
len(self.palabras) - 1)][1])))
self.btnOpcion1.modificarString(
self.lista_to_str_espaciado(
self.invetirOracion(
self.palabras[self.num_aleatorio(
0,
len(self.palabras) - 1)][1])))
self.btnOpcion4.modificarString(
self.lista_to_str_espaciado(
self.invetirOracion(
self.palabras[self.num_aleatorio(
0,
len(self.palabras) - 1)][1])))
elif (tipo == 4):
self.btnOpcion4.modificarString(self.mensaje_encriptado)
self.btnOpcion2.modificarString(
self.lista_to_str_espaciado(
self.invetirOracion(
self.palabras[self.num_aleatorio(
0,
len(self.palabras) - 1)][1])))
self.btnOpcion3.modificarString(
self.lista_to_str_espaciado(
self.invetirOracion(
self.palabras[self.num_aleatorio(
0,
len(self.palabras) - 1)][1])))
self.btnOpcion1.modificarString(
self.lista_to_str_espaciado(
self.invetirOracion(
self.palabras[self.num_aleatorio(
0,
len(self.palabras) - 1)][1])))
elif (tipo == 2):
#encriptar ATBASH
self.pregunta.modificarTexto(self.titulos["e_atbash"])
self.mensaje_encriptado = self.encriptar_atbash(
self.mensaje_desencriptado)
self.pregunta2.modificarTexto(self.mensaje_desencriptado)
self.pregunta4.modificarTexto(
self.lista_to_str_espaciado(self.abecedario))
self.pregunta5.modificarTexto(
self.lista_to_str_espaciado(reversed(self.abecedario)))
self.pregunta6.modificarTexto(
"Seleccione la encripcion Correcta")
tipo = self.num_aleatorio(1, 4) #Pone el correcto
if (tipo == 1):
self.btnOpcion1.modificarString(self.mensaje_encriptado)
self.btnOpcion2.modificarString(
self.encriptar_atbash(self.palabras[self.num_aleatorio(
0,
len(self.palabras) - 1)][1]))
self.btnOpcion3.modificarString(
self.encriptar_atbash(self.palabras[self.num_aleatorio(
0,
len(self.palabras) - 1)][1]))
self.btnOpcion4.modificarString(
self.encriptar_atbash(self.palabras[self.num_aleatorio(
0,
len(self.palabras) - 1)][1]))
elif (tipo == 2):
self.btnOpcion2.modificarString(self.mensaje_encriptado)
self.btnOpcion1.modificarString(
self.encriptar_atbash(self.palabras[self.num_aleatorio(
0,
len(self.palabras) - 1)][1]))
self.btnOpcion3.modificarString(
self.encriptar_atbash(self.palabras[self.num_aleatorio(
0,
len(self.palabras) - 1)][1]))
self.btnOpcion4.modificarString(
self.encriptar_atbash(self.palabras[self.num_aleatorio(
0,
len(self.palabras) - 1)][1]))
elif (tipo == 3):
self.btnOpcion3.modificarString(self.mensaje_encriptado)
self.btnOpcion2.modificarString(
self.encriptar_atbash(self.palabras[self.num_aleatorio(
0,
len(self.palabras) - 1)][1]))
self.btnOpcion1.modificarString(
self.encriptar_atbash(self.palabras[self.num_aleatorio(
0,
len(self.palabras) - 1)][1]))
self.btnOpcion4.modificarString(
self.encriptar_atbash(self.palabras[self.num_aleatorio(
0,
len(self.palabras) - 1)][1]))
elif (tipo == 4):
self.btnOpcion4.modificarString(self.mensaje_encriptado)
self.btnOpcion2.modificarString(
self.encriptar_atbash(self.palabras[self.num_aleatorio(
0,
len(self.palabras) - 1)][1]))
self.btnOpcion3.modificarString(
self.encriptar_atbash(self.palabras[self.num_aleatorio(
0,
len(self.palabras) - 1)][1]))
self.btnOpcion1.modificarString(
self.encriptar_atbash(self.palabras[self.num_aleatorio(
0,
len(self.palabras) - 1)][1]))
elif (tipo == 3):
#encriptar Polibi
self.pregunta.modificarTexto(self.titulos["e_polibi"])
self.mensaje_encriptado = self.encriptar_polibi_5(
self.mensaje_desencriptado)
self.pregunta2.modificarTexto(self.mensaje_desencriptado)
self.pregunta5.modificarTexto(
"Seleccione la encripcion Correcta")
tipo = self.num_aleatorio(1, 4) #Pone el correcto
if (tipo == 1):
self.btnOpcion1.modificarString(self.mensaje_encriptado)
self.btnOpcion2.modificarString(
self.encriptar_polibi_5(
self.palabras[self.num_aleatorio(
0,
len(self.palabras) - 1)][1]))
self.btnOpcion3.modificarString(
self.encriptar_polibi_5(
self.palabras[self.num_aleatorio(
0,
len(self.palabras) - 1)][1]))
self.btnOpcion4.modificarString(
self.encriptar_polibi_5(
self.palabras[self.num_aleatorio(
0,
len(self.palabras) - 1)][1]))
elif (tipo == 2):
self.btnOpcion2.modificarString(self.mensaje_encriptado)
self.btnOpcion1.modificarString(
self.encriptar_polibi_5(
self.palabras[self.num_aleatorio(
0,
len(self.palabras) - 1)][1]))
self.btnOpcion3.modificarString(
self.encriptar_polibi_5(
self.palabras[self.num_aleatorio(
0,
len(self.palabras) - 1)][1]))
self.btnOpcion4.modificarString(
self.encriptar_polibi_5(
self.palabras[self.num_aleatorio(
0,
len(self.palabras) - 1)][1]))
elif (tipo == 3):
self.btnOpcion3.modificarString(self.mensaje_encriptado)
self.btnOpcion2.modificarString(
self.encriptar_polibi_5(
self.palabras[self.num_aleatorio(
0,
len(self.palabras) - 1)][1]))
self.btnOpcion1.modificarString(
self.encriptar_polibi_5(
self.palabras[self.num_aleatorio(
0,
len(self.palabras) - 1)][1]))
self.btnOpcion4.modificarString(
self.encriptar_polibi_5(
self.palabras[self.num_aleatorio(
0,
len(self.palabras) - 1)][1]))
elif (tipo == 4):
self.btnOpcion4.modificarString(self.mensaje_encriptado)
self.btnOpcion2.modificarString(
self.encriptar_polibi_5(
self.palabras[self.num_aleatorio(
0,
len(self.palabras) - 1)][1]))
self.btnOpcion3.modificarString(
self.encriptar_polibi_5(
self.palabras[self.num_aleatorio(
0,
len(self.palabras) - 1)][1]))
self.btnOpcion1.modificarString(
self.encriptar_polibi_5(
self.palabras[self.num_aleatorio(
0,
len(self.palabras) - 1)][1]))
elif (tipo == 4):
#encriptar cesar
self.pregunta.modificarTexto(self.titulos["e_cesar"])
self.mensaje_encriptado = self.CodificarCesar(
self.mensaje_desencriptado, 3)
self.pregunta2.modificarTexto(self.mensaje_desencriptado)
self.pregunta4.modificarTexto(
self.lista_to_str_espaciado(self.abecedario))
self.pregunta5.modificarTexto(
self.lista_to_str_espaciado(reversed(self.abecedario)))
self.pregunta6.modificarTexto(
"Seleccione la encripcion Correcta")
tipo = self.num_aleatorio(1, 4) #Pone el correcto
if (tipo == 1):
self.btnOpcion1.modificarString(self.mensaje_encriptado)
self.btnOpcion2.modificarString(
self.CodificarCesar(
self.palabras[self.num_aleatorio(
0,
len(self.palabras) - 1)][1], 3))
self.btnOpcion3.modificarString(
self.CodificarCesar(
self.palabras[self.num_aleatorio(
0,
len(self.palabras) - 1)][1], 3))
self.btnOpcion4.modificarString(
self.CodificarCesar(
self.palabras[self.num_aleatorio(
0,
len(self.palabras) - 1)][1], 3))
elif (tipo == 2):
self.btnOpcion2.modificarString(self.mensaje_encriptado)
self.btnOpcion1.modificarString(
self.CodificarCesar(
self.palabras[self.num_aleatorio(
0,
len(self.palabras) - 1)][1], 3))
self.btnOpcion3.modificarString(
self.CodificarCesar(
self.palabras[self.num_aleatorio(
0,
len(self.palabras) - 1)][1], 3))
self.btnOpcion4.modificarString(
self.CodificarCesar(
self.palabras[self.num_aleatorio(
0,
len(self.palabras) - 1)][1], 3))
elif (tipo == 3):
self.btnOpcion3.modificarString(self.mensaje_encriptado)
self.btnOpcion2.modificarString(
self.CodificarCesar(
self.palabras[self.num_aleatorio(
0,
len(self.palabras) - 1)][1], 3))
self.btnOpcion1.modificarString(
self.CodificarCesar(
self.palabras[self.num_aleatorio(
0,
len(self.palabras) - 1)][1], 3))
self.btnOpcion4.modificarString(
self.CodificarCesar(
self.palabras[self.num_aleatorio(
0,
len(self.palabras) - 1)][1], 3))
elif (tipo == 4):
self.btnOpcion4.modificarString(self.mensaje_encriptado)
self.btnOpcion2.modificarString(
self.CodificarCesar(
self.palabras[self.num_aleatorio(
0,
len(self.palabras) - 1)][1], 3))
self.btnOpcion3.modificarString(
self.CodificarCesar(
self.palabras[self.num_aleatorio(
0,
len(self.palabras) - 1)][1], 3))
self.btnOpcion1.modificarString(
self.CodificarCesar(
self.palabras[self.num_aleatorio(
0,
len(self.palabras) - 1)][1], 3))
else:
tipo = self.num_aleatorio(0, len(self.palabras) - 1)
(_, self.mensaje_desencriptado) = self.palabras[tipo]
tipo = self.num_aleatorio(1, 4)
self.pregunta1.modificarTexto("La Palabra a Desencriptar es:")
if (tipo == 1):
#Invertida
self.pregunta.modificarTexto(self.titulos["d_invertir"])
self.mensaje_encriptado = self.lista_to_str_espaciado(
self.invetirOracion(self.mensaje_desencriptado))
self.pregunta2.modificarTexto(self.mensaje_encriptado)
self.pregunta3.modificarTexto(
"Seleccione la Desencripcion correcta")
elif (tipo == 2):
#encriptar ATBASH
self.pregunta.modificarTexto(self.titulos["d_atbash"])
self.mensaje_encriptado = self.encriptar_atbash(
self.mensaje_desencriptado)
self.pregunta2.modificarTexto(self.mensaje_encriptado)
self.pregunta4.modificarTexto(
self.lista_to_str_espaciado(self.abecedario))
self.pregunta5.modificarTexto(
self.lista_to_str_espaciado(reversed(self.abecedario)))
self.pregunta6.modificarTexto(
"Seleccione la encripcion Correcta")
elif (tipo == 3):
#encriptar Polibi
self.pregunta.modificarTexto(self.titulos["d_polibi"])
self.mensaje_encriptado = self.encriptar_polibi_5(
self.mensaje_desencriptado)
self.pregunta2.modificarTexto(self.mensaje_encriptado)
self.pregunta5.modificarTexto(
"Seleccione la encripcion Correcta")
elif (tipo == 4):
#encriptar cesar
self.pregunta.modificarTexto(self.titulos["d_cesar"])
self.mensaje_encriptado = self.CodificarCesar(
self.mensaje_desencriptado, 3)
self.pregunta2.modificarTexto(self.mensaje_encriptado)
self.pregunta4.modificarTexto(
self.lista_to_str_espaciado(self.abecedario))
self.pregunta5.modificarTexto(
self.lista_to_str_espaciado(reversed(self.abecedario)))
self.pregunta6.modificarTexto(
"Seleccione la encripcion Correcta")
tipo = self.num_aleatorio(1, 4) #Pone el correcto
if (tipo == 1):
self.btnOpcion1.modificarString(self.mensaje_desencriptado)
self.btnOpcion2.modificarString(
self.palabras[self.num_aleatorio(0,
len(self.palabras) -
1)][1])
self.btnOpcion3.modificarString(
self.palabras[self.num_aleatorio(0,
len(self.palabras) -
1)][1])
self.btnOpcion4.modificarString(
self.palabras[self.num_aleatorio(0,
len(self.palabras) -
1)][1])
elif (tipo == 2):
self.btnOpcion2.modificarString(self.mensaje_desencriptado)
self.btnOpcion1.modificarString(
self.palabras[self.num_aleatorio(0,
len(self.palabras) -
1)][1])
self.btnOpcion3.modificarString(
self.palabras[self.num_aleatorio(0,
len(self.palabras) -
1)][1])
self.btnOpcion4.modificarString(
self.palabras[self.num_aleatorio(0,
len(self.palabras) -
1)][1])
elif (tipo == 3):
self.btnOpcion3.modificarString(self.mensaje_desencriptado)
self.btnOpcion2.modificarString(
self.palabras[self.num_aleatorio(0,
len(self.palabras) -
1)][1])
self.btnOpcion1.modificarString(
self.palabras[self.num_aleatorio(0,
len(self.palabras) -
1)][1])
self.btnOpcion4.modificarString(
self.palabras[self.num_aleatorio(0,
len(self.palabras) -
1)][1])
elif (tipo == 4):
self.btnOpcion4.modificarString(self.mensaje_desencriptado)
self.btnOpcion2.modificarString(
self.palabras[self.num_aleatorio(0,
len(self.palabras) -
1)][1])
self.btnOpcion3.modificarString(
self.palabras[self.num_aleatorio(0,
len(self.palabras) -
1)][1])
self.btnOpcion1.modificarString(
self.palabras[self.num_aleatorio(0,
len(self.palabras) -
1)][1])
def modificar_tiempo(self, tiempo):
self.tiempo = tiempo
def quitar_vida(self):
self.vida_actuales -= 1
def get_vidas_actuales(self):
return self.vida_actuales
def get_puntuacion(self):
return self.puntuacion
def compararOpcion(self, opcion):
return opcion == self.mensaje_encriptado or opcion == self.mensaje_desencriptado
def sumarPuntaje(self):
self.puntuacion += self.tiempoJuego
def invertirPalabra(self, palabra):
"""
Invierte Palabra::
"Hola" -> "aloH"
@param palabra: palabra que se va a invertir
@type palabra: str
@return: Palabra convertida
@rtype: str
"""
return ''.join(reversed(palabra))
def invetirOracion(self, Oracion):
"""
Invierte Oracion, pero retorna una lista::
"Hola Mundo" -> ["aloH", "odnuM"]
@param palabra: Oracion que se va a invertir
@type palabra: str
@return: Lista con Oracion Convertida
@rtype: list
"""
lista = Oracion.split()
return list(map(self.invertirPalabra, lista))
def lista_to_str_espaciado(self, lista):
"""
Imprime con espaciado una lista::
["aloH", "odnuM"] -> "aloH odnuM"
@param lista: Lista que se va a convertir
@type lista: list
@return: Oracion de la lista con espacios
@rtype: str
"""
return " ".join(lista)
def encriptar_atbash(self, message):
"""
Metodo que encripta con metodo atbash::
Con el alfabeto
A B C D E F G H I J K L M N Ñ O P Q R S T U V W X Y Z
Z Y X W V U T S R Q P O Ñ N M L K J I H G F E D C B A
----------------------------------------------------
Lo que trata de hacer es modificar la letra de arriba con la
respectiva de abajo, el ejemplo:
"HOLA MUNDO" -> "SLOZ ÑFNWL"
@param message: mensaje a Encriptar
@type message: str
@return: mensaje encriptado
@rtype: str
"""
alphabet = u'A B C D E F G H I J K L M N Ñ O P Q R S T U V W X Y Z a b c d e f g h i j k l m n ñ o p q r s t u v w x y z 0 1 2 3 4 5 6 7 8 9'.split(
)
backward = u'Z Y X W V U T S R Q P O Ñ N M L K J I H G F E D C B A z y x w v u t s r q p o ñ n m l k j i h g f e d c b a 9 8 7 6 5 4 3 2 1 0'.split(
)
cipher = []
for letter in message:
if letter in alphabet:
for i in xrange(len(alphabet)):
if alphabet[i] == letter:
pos = i
cipher.append(backward[pos])
else:
cipher.append(letter)
newMessage = ''.join(cipher)
return newMessage
def desencriptar_atbash(self, message):
"""
Metodo para desencriptar con metodo atbash::
Con el alfabeto
A B C D E F G H I J K L M N Ñ O P Q R S T U V W X Y Z
Z Y X W V U T S R Q P O Ñ N M L K J I H G F E D C B A
----------------------------------------------------
Lo que trata de hacer es modificar la letra de arriba con la
respectiva de abajo, el ejemplo:
"SLOZ ÑFNWL" -> "HOLA MUNDO"
@param message: mensaje a Desencriptar
@type message: str
@return: mensaje Desencriptado
@rtype: str
"""
alphabet = u'A B C D E F G H I J K L M N Ñ O P Q R S T U V W X Y Z a b c d e f g h i j k l m n ñ o p q r s t u v w x y z 0 1 2 3 4 5 6 7 8 9'.split(
)
backward = u'Z Y X W V U T S R Q P O Ñ N M L K J I H G F E D C B A z y x w v u t s r q p o ñ n m l k j i h g f e d c b a 9 8 7 6 5 4 3 2 1 0'.split(
)
cipher = []
for letter in message:
if letter in backward:
for i in xrange(len(backward)):
if backward[i] == letter:
pos = i
cipher.append(alphabet[pos])
else:
cipher.append(letter)
newMessage = ''.join(cipher)
return newMessage
def codificar_polibi_5(self, char):
"""
Codifica una letra en formato polibi::
"H" -> (3,3) como ejemplo
@param char: caracter a convertir
@type char: str
@return: Tupla con el valor convertido en polibi
@rtype: (a, b)
"""
alfabeto = "abcdefghiklmnopqrstuvwxyz"
tup = (0, 0)
if char:
if alfabeto.find(char) <= 5:
tup = (1, alfabeto.find(char) + 1)
elif alfabeto.find(char) <= 10:
tup = (2, (alfabeto.find(char) + 1) - 5)
elif alfabeto.find(char) <= 15:
tup = (3, (alfabeto.find(char) + 1) - 10)
elif alfabeto.find(char) <= 20:
tup = (4, (alfabeto.find(char) + 1) - 15)
elif alfabeto.find(char) <= 25:
tup = (5, (alfabeto.find(char) + 1) - 20)
return "".join(map(str, tup))
def encriptar_str_polibi_5(self, texto):
"""
Encripta una palabra a codigo polibi::
"HOLA" -> [(1,2),(2,3),(3,4),(4,5)]
@param texto: Palabra a encriptar
@type texto: str
@return: Lista encriptada en polibi
@rtype: [(a,b),(c,d)]
"""
return " ".join(map(self.codificar_polibi_5, texto))
def encriptar_polibi_5(self, mensaje):
"""
Encripta una palabra convertida y las une como una lista, imprime un str
::
"HOLA MUNDO" -> "(1,1),(1,2),(1,3),(1,4)-(2,1),(2,2),(2,3),(2,4),(2,5)"
@param mensaje: Mensaje a encriptar
@type mensaje: str
@return: str con mensaje encriptado
@rtype: str
"""
mensaje = mensaje.replace("j", "i")
lista = mensaje.split()
lista = map(self.encriptar_str_polibi_5, lista)
return "-".join(lista)
#return self.lista_to_str_espaciado(lista)
def CodificarCesar(self, Palabra, Avance):
"""
Codifica Mensaje con codficacion atbas, sin embargo, el orden del abecderio
no es el mismo::
A B C D E F G H I J K L M N Ñ O P Q R S T U V W X Y Z
Y X W V U T S R Q P O Ñ N M L K J I H G F E D C B A Z
------------------------------------------------------
@param Palabra: Palabra a criptar
@type Palabra: str
@param Avance: avance o cambio de orden del abecedario
@type Avance: int
@return: Palabra invertida
@rtype: str
"""
alfabetoMinus = [
'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y',
'z'
]
alfabetoMayus = [
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
'N', 'Ñ', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y',
'Z'
]
Clave = ''
Tope = len(alfabetoMayus)
Posicion = 0
for letra in Palabra:
for i in range(Tope):
if (i + Avance < Tope):
Posicion = i + Avance
else:
Posicion = abs((Tope - i) - Avance)
if letra == alfabetoMinus[i]:
Clave = Clave + alfabetoMinus[Posicion]
elif letra == alfabetoMayus[i]:
Clave = Clave + alfabetoMayus[Posicion]
return Clave
class Curso_service:
"""
Servicio de eventos para los cursos, su estructura va formada como scripting
"""
def __init__(self):
"""
Constructor fachada
"""
self.conexion = Conexion()
def ver_todos(self):
"""
Se obtienen todos los cursos de la base de datos
@return: Lista de cursos en la base de datos
@rtype: <class 'list'>
"""
query = "SELECT * FROM curso;"
consulta = self.conexion.enviar_consulta(query)
return consulta
def guardar(self, curso):
"""
Servicio para guardado de datos del curso
@param curso: Datos del curso al que se debe guardar en la base de datos
@type curso: <clase= 'Curso'>
@return: True si se guardaron los datos correctamente
@rtype: boolean
"""
f1 = "{}-{}-{}".format(curso.dia_reunion.year, curso.dia_reunion.month,
curso.dia_reunion.day)
query = """
INSERT INTO curso(nombre, aula, tiempo, dia_reunion, edificio, profesor)
VALUES ('{}', '{}', {}, '{}', {}, {});""".format(
curso.nombre, curso.aula, curso.tiempo, f1, curso.edificio,
curso.profesor)
return (not self.conexion.enviar_registro(query))
def cursos_profesor(self, profesor):
"""
Muestra los cursos del profesor, espeficado, los que tiene administracion total
@param profesor: Id de profesor
@type profesor: int
@return: Lista de datos que tiene que ver con el profesor en cuestion
@rtype: [tuple]
"""
query = "SELECT * FROM curso WHERE profesor={}".format(profesor)
return self.conexion.enviar_consulta(query)
def eliminar(self, curso):
"""
Elimina un curso de la base de datos
@param curso: id del curso a eliminar
@type curso: int
@return: True si se hizo correctamente
@rtype: boolean
"""
query = "DELETE FROM curso WHERE id_curso={};".format(curso)
return (not self.conexion.enviar_registro(query))
def modificar(self, curso):
"""
Modifica un curso de la base de datos
@param curso: datos generales del curso
@type curso: <class= 'Curso'>
@return: True si se hizo correctamente
@rtype: boolean
"""
f1 = "{}-{}-{}".format(curso.dia_reunion.year, curso.dia_reunion.month,
curso.dia_reunion.day)
query = """UPDATE curso SET (nombre, aula, tiempo, dia_reunion, edificio, profesor) = ('{}', '{}', {}, '{}', {}, {})
WHERE id_curso={}""".format(curso.nombre, curso.aula,
curso.tiempo, f1, curso.edificio,
curso.profesor, curso.id)
return (not self.conexion.enviar_registro(query))
def seleccionar(self, id_curso):
"""
Selecciona el curso de la base de datos y obtiene los valores correpondientes
@param id_curso: Id del curso que desea obtener los datos
@type id_curso: int
@return: Datos restablecidos con el id del curso
@rtype: tuple
"""
query = "SELECT * FROM curso WHERE id_curso={}".format(id_curso)
return self.conexion.enviar_consulta(query)