def main(entrada, usuario):
"""
Funcion main
param: string entrada: entrada es igual a cadena de a
param: variable indic: llama a la funcion matroz
param: variable a: llama a transformacion con parametros entrada, indic en posicion 0 y 1
param: variable b: llama a que_quieres con parametros a, indic en posicion 0 y 1
param: variable c: llama Vigenere con parametros b en posiciones [0,4] e indic en posicion 0 y 1
param: variable d: llama act_llave con parametros b en posicion 1, c , b en posicion 2 y 3 e indic en posicion 0 y 1
return: d
"""
#entrada = a
#usuario = 'Sergio'
indic = matroz()
a = transformacion(entrada, indic[0], indic[1])
b = que_quieres(a, indic[0], indic[1])
c = Vigenere(b[0], b[1], b[2], b[3], indic[0], indic[1])
d = act_llave(b[1], c, b[2], b[3], indic[0], indic[1])
mensaje = b[1]
clave = b[0]
if d != mensaje :
Archivos.arch_historial(mensaje,clave,d,usuario)
# escribir mensaje desencriptado
if len(d) > 40:
Archivos.arch_texto(d,usuario)
d = "Debido a la longitud del mensaje se creo un archivo en la carpeta Texto."
return d, mensaje, clave, usuario
def rsa(mensaje, clave, opcion, opcion2,usuario):
if opcion == 1:
c_publica,c_privada = crear_claves()
Archivos.arc_histo_rsa_llaves(c_publica,c_privada,usuario)
return c_publica, c_privada
if opcion == 0:
if opcion2 == 'enc':
mensaje = list(mensaje)
clave_publi = clave.split(",")
cad = encriptar_RSA(mensaje,clave_publi)
#se guarda el historial
Archivos.arch_historial(mensaje,clave_publi,cad,usuario)
if len(cad) > 40:
Archivos.arch_texto(cad,usuario)
cad = "Debido a la longitud del mensaje se creo un archivo en la carpeta Texto."
return cad
if opcion2 == 'des':
mensaje = mensaje.split(",")
clave_privi = clave.split(",")
cad = desencriptar_RSA(mensaje,clave_privi)
#se guarda el historial
Archivos.arch_historial(mensaje,clave_privi,cad,usuario)
if len (cad) > 40:
Archivos.arch_texto(cad,usuario)
cad = "Debido a la longitud del mensaje se creo un archivo en la carpeta Texto."
return cad
def esID(linea: str, posicion: int) -> str:
q0 = 0
F = {0, 1}
# Q = (0,1,2)
# sigma=[(letra, digito, guionBajo, otro)] #letra = 0ra columna, digito = 1da columna, guionBajo = 2ra columna, otro= 3ta columna)
delta = [None] * 3
for i in range(3):
delta[i] = [None] * 4
delta[0][0] = 1
delta[0][1] = 2
delta[0][2] = 2
delta[0][3] = 2
delta[1][0] = 1
delta[1][1] = 1
delta[1][2] = 1
delta[1][3] = 2
delta[2][0] = 2
delta[2][1] = 2
delta[2][2] = 2
delta[2][3] = 2
lexema = ""
auxControl = posicion
T = arc.leerCaracter(linea, auxControl)
estado = q0
while (estado != 2) and auxControl < len(linea) and (T != " ") and (
T != "\n") and not simbolo(linea, auxControl):
estado = delta[estado][simboloID(T)]
lexema = lexema + T
auxControl = auxControl + 1
T = arc.leerCaracter(linea, auxControl)
if estado in F:
return lexema
else:
return ""
def Desencriptar_Cesar(cadena1, mov, usuario):
"""
Desencriptar_Cesar esta funcion se encarga de hacer la desencriptacion en base al algorimo Cesar
:param string cadena1: El texto o mensaje que se desea desencriptar.
:param int mov: El numero de movimientos que desea que se mueva cada elemento de la cadena.
:return: mensaje encriptado.
"""
cadena2 = ""
if mov > 25 or mov < 0:
mov = mov % 26
for i in range(len(cadena1)):
val = ord(cadena1[i])
if cadena1[i] == " ":
cadena2 = cadena2 + " "
elif val >= 65 and val <= 90:
val = val - 65 - mov
if val < 0:
val = 26 + val
if val > 25:
val = val % 26
val = val + 65
cadena2 = cadena2 + chr(val)
elif val >= 97 and val <= 122:
val = val - 97 - mov
if val < 0:
val = 26 + val
if val > 25:
val = val % 26
val = val + 97
cadena2 = cadena2 + chr(val)
if len(cadena2) > 40:
Archivos.arch_texto(cadena2, usuario)
cadena2 = "Debido a la longitud del mensaje se creo un archivo en la carpeta Texto."
return cadena2
def esCADENA(linea: str, pos: int) -> str:
q0 = 0
F = [2]
#Q=0..3
# #sigma=(C,O);
delta = [None] * 4
for i in range(4):
delta[i] = [None] * 2
delta[0][0] = 1
delta[0][1] = 3
delta[1][0] = 2
delta[1][1] = 1
delta[2][0] = 3
delta[2][1] = 3
delta[3][0] = 3
delta[3][1] = 3
auxControl = pos
estado = q0
lexema = ''
T = arc.leerCaracter(linea, auxControl)
while estado != 3 and auxControl < len(linea) and T != "\n" and (estado
not in F):
estado = delta[estado][simbCAD(T)]
if estado != 3:
lexema = lexema + T
auxControl = auxControl + 1
T = arc.leerCaracter(linea, auxControl)
if estado in F:
pos = auxControl
return lexema
else:
return ""
def esLEER(linea: str, posicion: str) -> str:
q0 = 0
F = {4}
#Q=0..5
#sigma=(L, E, R, O)
delta = [None] * 6
for i in range(6):
delta[i] = [None] * 4
delta[0][0] = 1
delta[0][1] = 5
delta[0][2] = 5
delta[0][3] = 5
delta[1][0] = 5
delta[1][1] = 2
delta[1][2] = 5
delta[1][3] = 5
delta[2][0] = 5
delta[2][1] = 3
delta[2][2] = 5
delta[2][3] = 5
delta[3][0] = 5
delta[3][1] = 5
delta[3][2] = 4
delta[3][3] = 5
delta[4][0] = 5
delta[4][1] = 5
delta[4][2] = 5
delta[4][3] = 5
auxControl = posicion
estado = q0
lexema = ""
T = arc.leerCaracter(linea, auxControl)
while estado != 5 and auxControl < len(
linea) and T != " " and T != "\n" and not simbolo(
linea, auxControl):
estado = delta[estado][simbLEER(T)]
if estado != 5:
lexema = lexema + T
auxControl = auxControl + 1
T = arc.leerCaracter(linea, auxControl)
if estado in F:
return lexema
else:
return ""
def desencriptar_Solitario(cadena, clave, usuario):
"""
Dncriptar_Solitario esta funcion se encarga de hacer la desencriptacion en base al algorimo Solitario
:param string cadena1: El texto o mensaje que se desea desencriptar.
:param string clave: la clave con la cual es mensaje se restara para generar el mensaje desencriptado.
:return: mensaje desencriptado.
"""
cadenaaux = ""
for i in range(len(cadena)):
c1 = buscar(cadena[i])
z1 = buscar(clave[i])
op = c1 - z1
if op < 0:
op = 114 + op
pos = entregar(op)
cadenaaux += pos
if len(cadenaaux) >= 40:
Archivos.arch_texto(cadenaaux, usuario)
cadenaaux = "Debido a la longitud del mensaje se creo un archivo en la carpeta Texto."
return cadenaaux
def encriptar_Solitario(cadena, clave, clave_inicial, usuario):
"""
Encriptar_Solitario esta funcion se encarga de hacer la encriptacion en base al algorimo Solitario
:param string cadena1: El texto o mensaje que se desea encriptar.
:param string clave: la clave con la cual es mensaje se sumara para generar el mensaje encriptado.
:return: mensaje encriptado.
"""
cadenaaux = ""
for i in range(len(cadena)):
c1 = buscar(cadena[i])
z1 = buscar(clave[i])
op = c1 + z1
if op > 115:
op = op % 115
pos = entregar(op)
cadenaaux += pos
# llama a la funcion para guardar en el historial
Archivos.arch_historial(cadena, clave_inicial, cadenaaux, usuario)
if len(cadenaaux) >= 40:
Archivos.arch_texto(cadenaaux, usuario)
cadenaaux = "Debido a la longitud del mensaje se creo un archivo en la carpeta Texto."
return cadenaaux
def encriptar(mensaje, clave, clave_inicial, usuario):
"""
encriptar recibe el mensaje para encriptar y su respectiva clave, le aplica la tabla de verdad XOR a los codigos binarios de estos
:param strign x: mensaje en mayuscula
:param strign y: clave en maniscula
:param lista mensaje_binario: codigos binarios del mensaje
:param lista clave_binario: codigos binarios de la clave
:param lista mensaje_encriptado: lista de codigos binarios
:param string string_encriptada: string despues de realizar la encriptación con el metodo Vernam
:return: retorna cadena de caracteres encriptados
"""
x = mensaje.upper()
y = clave.lower()
mensaje_binario = s2b(x)
clave_binario = s2b(y)
mensaje_encriptado = []
for i in range(0, len(mensaje_binario)):
res = ""
for j in range(0, 8):
x = mensaje_binario[i]
y = x[j]
x2 = clave_binario[i]
y2 = x2[j]
if x == "01000000":
res += "01000000"
break
elif y == y2:
res += "0"
else:
res += "1"
mensaje_encriptado.append(res)
string_encriptada = b2s(mensaje_encriptado)
Archivos.arch_historial(mensaje, clave_inicial, string_encriptada, usuario)
if len(mensaje) > 40:
Archivos.arch_texto(string_encriptada, usuario)
string_encriptada = "Debido a la longitud del mensaje se creo un archivo en la carpeta Texto."
return string_encriptada
def get_area(self):
self.actas= Archivos.get_actas(self.area)
return self.actas
def esConstReal(linea: str, pos: int) -> str:
q0 = 0
F = {4, 2, 7}
#Q=range(1,9)
#sigma=(D, menos, punto, E, O)
delta = [None] * 9
for i in range(9):
delta[i] = [None] * 5
estado = q0
auxControl = pos
delta[0][0] = 2
delta[0][1] = 1
delta[0][2] = 8 # 8=muerto
delta[0][3] = 8
delta[0][4] = 8
delta[1][0] = 2
delta[1][1] = 8
delta[1][2] = 8
delta[1][3] = 8
delta[1][4] = 8
delta[2][0] = 2
delta[2][1] = 8
delta[2][2] = 3
delta[2][3] = 5
delta[2][4] = 8
delta[3][0] = 4
delta[3][1] = 8
delta[3][2] = 8
delta[3][3] = 8
delta[3][4] = 8
delta[4][0] = 4
delta[4][1] = 8
delta[4][2] = 8
delta[4][3] = 5
delta[4][4] = 8
delta[5][0] = 7
delta[5][1] = 6
delta[5][2] = 8
delta[5][3] = 8
delta[5][4] = 8
delta[6][0] = 7
delta[6][1] = 8
delta[6][2] = 8
delta[6][3] = 8
delta[6][4] = 8
delta[7][0] = 7
delta[7][1] = 8
delta[7][2] = 8
delta[7][3] = 8
delta[7][4] = 8
delta[8][0] = 8
delta[8][1] = 8
delta[8][2] = 8
delta[8][3] = 8
delta[8][4] = 8
lexema = ""
T = arc.leerCaracter(linea, auxControl)
while estado != 8 and auxControl < len(
linea) and T != " " and T != "\n" and (not simbolo1(
linea, auxControl)):
estado = delta[estado][simbCONS(T)]
if estado != 8:
lexema = lexema + T
auxControl = auxControl + 1
T = arc.leerCaracter(linea, auxControl)
if estado in F:
return lexema
else:
return ""
def simbolo1(linea: str, posicion: int) -> bool:
simb = False
aux = arc.leerCaracter(linea, posicion)
if aux in {'=', '+', '*', '/', ';', ',', '(', ')'}:
simb = True
return simb
def esESCRIBIR(linea: str, pos: int) -> int:
q0 = 0
F = {8}
#Q=0..9;
# #sigma=(E, S, C, R, I, B ,O) 0 para E, 1 para S, 2 para C...
#delta = np.empty((10, 7))
delta = [None] * 10
for i in range(10):
delta[i] = [None] * 7
delta[0][0] = 1
delta[0][1] = 9
delta[0][2] = 9
delta[0][3] = 9
delta[0][4] = 9
delta[0][5] = 9
delta[0][6] = 9
delta[1][0] = 9
delta[1][1] = 2
delta[1][2] = 9
delta[1][3] = 9
delta[1][4] = 9
delta[1][5] = 9
delta[1][6] = 9
delta[2][0] = 9
delta[2][1] = 9
delta[2][2] = 3
delta[2][3] = 9
delta[2][4] = 9
delta[2][5] = 9
delta[2][6] = 9
delta[3][0] = 9
delta[3][1] = 9
delta[3][2] = 9
delta[3][3] = 4
delta[3][4] = 9
delta[3][5] = 9
delta[3][6] = 9
delta[4][0] = 9
delta[4][1] = 9
delta[4][2] = 9
delta[4][3] = 9
delta[4][4] = 5
delta[4][5] = 9
delta[4][6] = 9
delta[5][0] = 9
delta[5][1] = 9
delta[5][2] = 9
delta[5][3] = 9
delta[5][4] = 9
delta[5][5] = 6
delta[5][6] = 9
delta[6][0] = 9
delta[6][1] = 9
delta[6][2] = 9
delta[6][3] = 9
delta[6][4] = 7
delta[6][5] = 9
delta[6][6] = 9
delta[7][0] = 9
delta[7][1] = 9
delta[7][2] = 9
delta[7][3] = 8
delta[7][4] = 9
delta[7][5] = 9
delta[7][6] = 9
delta[8][0] = 9
delta[8][1] = 9
delta[8][2] = 9
delta[8][3] = 9
delta[8][4] = 9
delta[8][5] = 9
delta[8][6] = 9
delta[9][0] = 9
delta[9][1] = 9
delta[9][2] = 9
delta[9][3] = 9
delta[9][4] = 9
delta[9][5] = 9
delta[9][6] = 9
auxControl = pos
estado = q0
lexema = ""
T = arc.leerCaracter(linea, pos)
while estado != 9 and auxControl < len(
linea) and T != " " and T != "\n" and not simbolo(
linea, auxControl):
estado = delta[estado][simbESCRI(T)]
if estado != 9:
lexema = lexema + T
auxControl = auxControl + 1
T = arc.leerCaracter(linea, auxControl)
if estado in F:
posicion = auxControl
return lexema
else:
return ""
def __init__(self,
archivo): #se ejecuta solo al crear el Lexico (constructor)
self.posNueva = 0 #guarda la posicion actual en la linea
self.lineas = arc.leerLineas(
archivo) #lee todas las lineas poniendo cada linea en un vector
self.l = 0 #guarda la linea actual
def guardar(self, acta):
self.actas.append(acta)
Archivos.guardar_actas(self.actas, self.area)
def main():
##menu funciona desde aqui
miListaUsuarios = ListaDobleCircularUsuario.ListaDobleCircularUsuario()
miListaUsuarios.insertarUsuarioFinal("Alejandra", "Alejandra")
miListaUsuarios.insertarUsuarioFinal("Julissa", "Julissa")
miListaUsuarios.insertarUsuarioFinal("Dayanna", "Dayanna")
miListaUsuarios.insertarUsuarioFinal("Sindy", "Sindy")
miListaUsuarios.insertarUsuarioFinal("Benjamin", "Benjamin")
miListaUsuarios.insertarUsuarioFinal("Evelyn", "Evelyn")
miListaUsuarios.insertarUsuarioFinal("Elizabeth", "Elizabeth")
miListaUsuarios.insertarUsuarioFinal("Vanessa", "Vanessa")
miListaUsuarios.insertarUsuarioFinal("Brenda", "Brenda")
sessionIniciada = False
opcionPrincipal = 0
menu = Menus.Menus()
while (opcionPrincipal != 3):
opcionPrincipal = menu.menu_principal()
if opcionPrincipal == 1:
print("Creando Usuario")
nombre = raw_input("Ingrese Nombre: ")
password = raw_input("Ingrese Password: "******"Ingrese Usuario: ")
clave = raw_input("Ingrese Password: "******"Ingrese el nombre del archivo: ")
ruta = os.path.dirname(os.path.abspath(__file__))
ruta = ruta + "\\" + pathArchivo
print ruta
if os.path.isfile(ruta):
miMatriz = Matriz.Matriz()
miArchivo = Archivos.Archivos()
contenidoArchivo = miArchivo.leerArchivoEntradaCompleto(
pathArchivo)
filaColumna = miArchivo.obtenerTamanioMatriz(
contenidoArchivo)
dimensionesMatriz = filaColumna.split(",")
filas = int(dimensionesMatriz[0])
columnas = int(dimensionesMatriz[1])
if usuarioActual.archivoCargado == False:
miMatriz.crearMatriz(filas, columnas)
usuarioActual.archivoCargado = True
usuarioActual.matrizUsuario = miMatriz
usuarioActual.matrizTranspuesta = miMatriz.operarMatrizTranspuesta(
)
print "***************************"
print " Matriz Creada "
print "***************************"
else:
print "*********************************************"
print " Ignorando la Matriz del Nuevo Archivo "
print "*********************************************"
operaciones = miArchivo.obtenerOperacionesDesdeArchivo(
contenidoArchivo)
listadoOperaciones = operaciones.split(",")
cadActual = ""
for opera in listadoOperaciones:
operacionChain = ""
cadActual = opera
cadActual = cadActual.split()
for cd in cadActual:
if operacionChain == "":
operacionChain = cd
else:
operacionChain = operacionChain + " " + cd
if operacionChain != "":
usuarioActual.colaOperacionesUser.insertaElementoColaOperaciones(
operacionChain)
print "***************************"
print " Operacion Ingresada "
print "***************************"
print "***************************"
print " Archivo Leido "
print "***************************"
else:
print "***************************"
print " El archivo no existe "
print "***************************"
elif opcionUsuario == 2:
if usuarioActual.archivoCargado == True:
print "***************************"
print " Resolver Operacion "
print "***************************"
opcionRevolverOperaciones = 0
while (opcionRevolverOperaciones != 2):
opcionRevolverOperaciones = menu.menu_operacion(
)
if opcionRevolverOperaciones == 1:
if usuarioActual.colaOperacionesUser.tamanioCola > 0:
## print "resolviendo siguiente Operacion"
operacionActual = ""
nodoOperacionActual = usuarioActual.colaOperacionesUser.obtenerElementoEliminarElementoColaOperaciones(
)
## operacionActual = usuarioActual.colaOperacionesUser.eliminarElementoColaOperaciones()
operacionActual = nodoOperacionActual.operacion
operacionActual = operacionActual.split(
)
print nodoOperacionActual.operacion
for elemento in operacionActual:
if elemento != "+" and elemento != "-" and elemento != "*":
datoo = int(elemento)
nodoOperacionActual.pilaOperacion.insertarNodoPilaOperacionesFinal(
datoo, elemento)
else:
## datoo = int(elemento)
nodoOperacionActual.pilaOperacion.insertarNodoPilaOperacionesFinal(
0, elemento)
print "******************************************"
resulFinal = 0
print "Al realizar la operacion: " + nodoOperacionActual.operacion
resulFinal = nodoOperacionActual.pilaOperacion.primeroPila.valor
print "El resultado es: " + str(
resulFinal)
print "******************************************"
else:
print "***************************"
print " No hay Operaciones "
print "***************************"
print "***************************"
print "Regresando a menu Operacion"
print "***************************"
else:
print "*******************************"
print " Cargue primero un archivo "
print "*******************************"
elif opcionUsuario == 3:
if usuarioActual.archivoCargado == True:
print "operar matriz"
opcionEnMatriz = 0
while (opcionEnMatriz != 5):
opcionEnMatriz = menu.menu_matriz()
if opcionEnMatriz == 1:
print "***************************"
print " Ingresando dato en matriz "
print "***************************"
mensaje = "Ingrese posicion X: "
posX = validarEntradaCorrectaNumero(
mensaje)
while posX == -999:
mensaje = "Ingrese posicion X: "
posX = validarEntradaCorrectaNumero(
mensaje)
## posX = int(raw_input("Ingrese posicion X: "))
mensaje = "Ingrese posicion Y: "
posY = validarEntradaCorrectaNumero(
mensaje)
while posY == -999:
mensaje = "Ingrese posicion Y: "
posY = validarEntradaCorrectaNumero(
mensaje)
## posY = int(raw_input("Ingrese posicion Y: "))
mensaje = "Ingrese el valor a ingresar X: "
valorIngresar = validarEntradaCorrectaNumero(
mensaje)
while posX == -999:
mensaje = "Ingrese el valor a ingresar X: "
valorIngresar = validarEntradaCorrectaNumero(
mensaje)
## valorIngresar = int(raw_input("Ingrese el valor a ingresar X: "))
seInserto = usuarioActual.matrizUsuario.ingresarValorMatriz(
posX, posY, valorIngresar)
if seInserto == True:
print "***************************"
print " Dato Ingresado "
print "***************************"
elif opcionEnMatriz == 2:
print "***************************"
print " Operar transpuesta "
print "***************************"
usuarioActual.matrizUsuario.operarMatrizTranspuesta(
)
print "********************************"
elif opcionEnMatriz == 3:
print "*****************************"
print " Mostrar matriz original "
print "*****************************"
usuarioActual.matrizUsuario.mostrarMatrizOriginal(
)
print "********************************"
elif opcionEnMatriz == 4:
print "********************************"
print " Mostrar Matriz transpuesta "
print "********************************"
usuarioActual.matrizUsuario.mostrarMatrizTranspuesta(
)
print "********************************"
print "***************************"
print "Regresando a menu usuario"
print "***************************"
else:
print "*******************************"
print " Cargue primero un archivo "
print "*******************************"
elif opcionUsuario == 4:
print "*****************************"
print " Mostrar Lista de Usuarios "
print "*****************************"
cadenaAdelante = miListaUsuarios.mostrarListadoNicksAdelante(
)
cadenaAtras = miListaUsuarios.mostrarListadoNicksAtras(
)
miListaUsuarios.crearArchivoDot()
miListaUsuarios.verImagen()
## miListaUsuarios.verImagen2()
print cadenaAdelante
print cadenaAtras
print "************************************************"
elif opcionUsuario == 5:
print "*****************************"
print " Mostrar Cola de Operaciones "
print "*****************************"
usuarioActual.colaOperacionesUser.mostrarColaDeOperaciones(
)
usuarioActual.colaOperacionesUser.mostrarColaDeOperacionesOtra(
)
if usuarioActual.colaOperacionesUser.primeroCola != None:
usuarioActual.colaOperacionesUser.crearArchivoDot(
usuarioActual.nombreUsuario)
usuarioActual.colaOperacionesUser.verImagenCola()
print "********************************************************"
sessionIniciada == False
print "*******************************"
print " Sesion Finalizada "
print "*******************************"
else:
print "Verifique los datos no se puede Ingresar al Sistema"
print "******************************************************"
opcionPrincipal = 0
print "Hasta Pronto!!!"
def main():
def crono():
global segundos
global minutos
segundos = int(segundos)
if segundos == 60:
segundos = 0
minutos += 1
return crono()
else:
segundos += 1
time.sleep(1)
return crono()
""" Programa Principal """
pygame.init()
puntuacion = pygame.mixer.music.load("Sonido/intro2.wav")
pygame.mixer.music.play(2)
sonido = pygame.mixer.Sound("Sonido/choque.wav")
# Definimos el alto y largo de la pantalla
dimensiones = [LARGO_PANTALLA, ALTO_PANTALLA]
pantalla = pygame.display.set_mode(dimensiones)
pygame.display.set_caption("Cronometro")
def Reloj():
fuente1 = pygame.font.SysFont("Algerian", 30)
Reloj = str("Tiempo " + str(minutos) + ":" + str(segundos))
mensaje = fuente1.render(Reloj, 1, (BLANCO))
pantalla.blit(mensaje, (600, 10))
hilo = threading.Thread(target=crono, args=())
hilo.start()
# Creamos al protagonista
protagonista = Protagonista("Imagenes/bola2.png")
#imagenFondo = pygame.image.load("Imagenes/fondo1.jpg")
#imagenFondo = pygame.transform.scale(imagenFondo, (800,600))
# Creamos todos los niveles
listade_niveles = []
listade_niveles.append(Nivel_01(protagonista))
# Establecemos el nivel actual
nivel_actual_no = 0
nivel_actual = listade_niveles[nivel_actual_no]
lista_sprites_activos = pygame.sprite.Group()
protagonista.nivel = nivel_actual
protagonista.rect.x = 340
protagonista.rect.y = ALTO_PANTALLA - protagonista.rect.height
lista_sprites_activos.add(protagonista)
listade_monedas = pygame.sprite.Group()
listade_todos_los_sprites = pygame.sprite.Group()
z = 200
z1 = 590
z2 = 300
for i in range(4):
# ESto representa un bloque
monedas = Moneda("Imagenes/moneda.png")
monedas2 = Moneda("Imagenes/moneda.png")
monedas3 = Moneda("Imagenes/moneda.png")
# Definimos una ubicación aleatoria para el bloque
monedas.rect.x = z
monedas2.rect.x = z1
monedas3.rect.x = z2
monedas.rect.y = 350
monedas2.rect.y = 260
monedas3.rect.y = 110
z += 50
z1 += 50
z2 += 50
# Añadimos el bloque a la lista de objetos
listade_monedas.add(monedas)
listade_todos_los_sprites.add(monedas)
listade_monedas.add(monedas2)
listade_todos_los_sprites.add(monedas2)
listade_monedas.add(monedas3)
listade_todos_los_sprites.add(monedas3)
#Iteramos hasta que el usuario pulse sobre el botón de salida
hecho = False
# Lo usamos para gestionar cuan rápido se actualiza la pantalla.
reloj = pygame.time.Clock()
puntuacion = 0
puntosMonedas = 0
mifuenteSistema = pygame.font.SysFont("Algerian",
30) # obtener una fuente del sistema
miTextoSistema = mifuenteSistema.render("Puntos: ", 0, BLANCO)
miTextoSistema2 = mifuenteSistema.render("", 0, BLANCO)
miTextoSistema3 = mifuenteSistema.render("x 0", 0, BLANCO)
# -------- Bucle Principal del Programa -----------
while not hecho:
global segundos
for evento in pygame.event.get(): # El usuario realizó alguna acción
if evento.type == pygame.QUIT: # Si el usuario hizo click en salir
hecho = True # Marcamos como hecho y salimos de este bucle
if evento.type == pygame.KEYDOWN:
if evento.key == pygame.K_LEFT:
protagonista.ir_izquierda()
if evento.key == pygame.K_RIGHT:
protagonista.ir_derecha()
if evento.key == pygame.K_UP:
protagonista.saltar()
if evento.type == pygame.KEYUP:
if evento.key == pygame.K_LEFT and protagonista.cambio_x < 0:
protagonista.stop()
if evento.key == pygame.K_RIGHT and protagonista.cambio_x > 0:
protagonista.stop()
# Actualizamos al protagonista.
lista_sprites_activos.update()
listade_impactos_bloque = pygame.sprite.spritecollide(
protagonista, listade_monedas, True)
for monedas in listade_impactos_bloque:
puntuacion += 10
puntosMonedas += 1
sonido.play()
puntaje = str(puntuacion)
puntajeM = str(puntosMonedas)
miTextoSistema2 = mifuenteSistema.render(puntaje, 5, BLANCO)
miTextoSistema3 = mifuenteSistema.render(("X" + puntajeM), 5,
BLANCO)
L = str(puntuacion)
archi.creartxt("puntuaciones.txt")
archi.grabartxt("puntuaciones.txt", ("puntos:" + L))
print("La puntuacion es:", str(L))
# Actualizamos los objetos en este nivel
# Si el protagonista se aproxima al lado derecho, desplazamos su mundo a la izquierda (-x)
if protagonista.rect.right > LARGO_PANTALLA:
protagonista.rect.right = LARGO_PANTALLA
# Si el protagonista se aproxima al lado izquierdo, desplazamos su mundo a la derecha (+x)
if protagonista.rect.left < 0:
protagonista.rect.left = 0
# TODO EL CÓDIGO DE DIBUJO DEBERÍA IR DEBAJO DE ESTE COMENTARIO
nivel_actual.update()
nivel_actual.draw(pantalla)
lista_sprites_activos.draw(pantalla)
listade_todos_los_sprites.draw(pantalla)
pantalla.blit(imagenMoneda, (10, 10))
Reloj()
pantalla.blit(miTextoSistema, (260, 10))
pantalla.blit(miTextoSistema2, (380, 10))
pantalla.blit(miTextoSistema3, (45, 10))
# TODO EL CÓDIGO DE DIBUJO DEBERÍA IR ENCIMA DE ESTE COMENTARIO
# Limitamos a 60 fps
reloj.tick(60)
# Avanzamos y actualizamos la pantalla con todo lo que hemos dibujado.
pygame.display.flip()
# Pórtate bien con el IDLE. Si te olvidas de esta línea, el programa se 'colgará' al salir.
pygame.quit()
def actualizar(self):
self.actas=Archivos.get_actas(self.area)
#!/usr/bin/env python
import Alumnos
import Materias
import Archivos
n = "s"
archivo = Archivos.Archivos()
while n == "s":
print "-------------------------- SISTEMA DE REGISTRO ESCOLAR -------------------------\n"
print "Menu Principal:\n1) Alumnos\n2) Materias\n3) Crear Nuevo Archivo\n4) Salir\n"
opcion = int(raw_input("-> "))
if opcion == 4:
n = "n"
elif opcion == 1:
print "\nMenu Alumnos:\n1) Registrar\n2) Obtener Datos\n3) Longitud de Objeto\n4) Salir"
opc_alumno = int(raw_input("-> "))
if opc_alumno == 4:
n = "n"
elif opc_alumno == 1:
paterno = raw_input("Apellido Paterno: -> ")
materno = raw_input("Apellido Materno: -> ")
nombre = raw_input("Nombre(s): -> ")
matricula = raw_input("Matricula: -> ")
parametro_archivo = "\n---------------------------\n#Alumno\n", matricula, "\n", paterno, "\n", materno, "\n", nombre
