def seguir(self):
self.time = Temporizador(x=-300, y=300)
self.time.setDatas(0)
self.time.iniciar_aum()
self.texto.eliminar()
self.texto_nuevo = pilas.actores.Texto(
problemas[self.indice],
fuente="data/fonts/American Captain.ttf",
ancho=256)
self.texto_nuevo.color = pilas.colores.negro
self.personaje = pilas.actores.Actor("data/img/iconos/character.png",
x=700)
self.personaje.escala = 0.3
self.personaje.x = [400]
self.personaje.y = [-200]
self.mostrar_incorrecto()
class ControladorPomodoro(object):
def __init__(self):
self._proceso = ProcesoPomodoro()
def iniciar_pomodoro(self):
self._proceso.start()
self._lanzar_temporizador()
def avanzar_estado(self):
self._proceso.avanzar_estado()
self._lanzar_temporizador()
def _lanzar_temporizador(self):
estado_actual = self._proceso.get_estado()
self._temporizador = Temporizador(estado_actual.get_nombre())
self._temporizador.set_duracion(estado_actual.get_duracion())
self._temporizador.iniciar_cuenta_regresiva()
def interfaz(self):
#Timer
self.time = Temporizador(x=-250,y=300)
self.time.setDatas(0)
self.time.iniciar_aum()
#Titulo
self.texto_titulo = pilas.actores.Actor("data/img/enunciados/adivinanza.png",y=270)
self.texto_titulo.escala = 0.5
#Recuadro
self.recuadro = pilas.actores.Actor("data/img/interfaz/recuadrito.png",x = -20,y = 50)
self.recuadro.escala = 0.4
#Personaje
self.personaje = pilas.actores.Actor("data/img/iconos/character.png",y=-150)
self.personaje.escala = 0.26
self.personaje.decir("Clickea en el animal al que hace referencia la adivinanza") ###dialogo
#Adivinanza
numero = random.randrange(0,6)
self.adivinanza = adivinanzas[numero]
self.texto = pilas.actores.Texto(self.adivinanza,fuente="data/fonts/American Captain.ttf", y = 50 , ancho = 256 )
self.texto.color = pilas.colores.negro
def generar_palabra(self):
#Timer
self.time = Temporizador(x=-250,y=300)
self.time.setDatas(0)
self.time.iniciar_aum()
self.guion = []
self.letras_utilizadas = []
self.letras_adivinadas = 0
if(self.tema == 'Animales'):
self.palabra = random.choice(animales)
if(self.tema == 'Frutas'):
self.palabra = random.choice(frutas)
if(self.tema == 'Meses'):
self.palabra = random.choice(meses)
if(self.tema == 'Instrumentos'):
self.palabra = random.choice(instrumentos)
if (len(self.palabra) <= 5):
self.posx = -270
for x in range(0,len(self.palabra)):
self.actor_guion = pilas.actores.Actor("data/img/interfaz/guion.png",x=self.posx,y=-280)
self.guion.append(self.posx)
self.posx = self.posx + 100
self.actor_guion.escala = 0.12
elif(len(self.palabra) <= 9):
self.posx = -400
for x in range(0,len(self.palabra)):
self.actor_guion = pilas.actores.Actor("data/img/interfaz/guion.png",x=self.posx,y=-280)
self.guion.append(self.posx)
self.posx = self.posx + 100
self.actor_guion.escala = 0.12
else:
self.posx = -450
for x in range(0,len(self.palabra)):
self.actor_guion = pilas.actores.Actor("data/img/interfaz/guion.png",x=self.posx,y=-280)
self.guion.append(self.posx)
self.posx = self.posx + 80
self.actor_guion.escala = 0.09
def establecer_fecha_tiempo_de_inicio(objeto_json):
objeto_json['start'] = Temporizador.obtener_fecha_tiempo_actual()
return objeto_json
from temporizador import Temporizador
from time import sleep
def formato(valores):
return '{:02d} : {:02d} : {:02d}'.format(valores[0], valores[1],
valores[2])
t = Temporizador()
time = [0, 0, 5] #<--- Ingresar el valor del temporizador
t.iniciar(time)
tf = formato(time)
while True: #Retroceder
tiempo = t.mostrar_tiempo()
print tiempo
sleep(0.5)
if tiempo == "00 : 00 : 00":
break
t.retroceder()
while True: #Avanzar
t.avanzar()
tiempo = t.mostrar_tiempo()
print tiempo
sleep(0.5)
if tiempo == tf:
break
from temporizador import Temporizador
from time import sleep #esto es para que vaya mas despacio cuando muestra el tiempo#
t = Temporizador()
t.iniciar([0,1,15]) #aqui se pone el valor al que quiere llegar el temporizador#
while True:
tiempo = t.mostrar_tiempo()
print tiempo
sleep(0.2)
if tiempo == "00 : 00 : 00":
break
t.retroceder()
while True:
tiempo = t.mostrar_tiempo()
print tiempo
sleep(0.2)
if tiempo == "00 : 01 : 15":
break
t.avanzar()
from temporizador import Temporizador
from time import sleep
t = Temporizador()
t.iniciar([0, 0, 15])
while True:
tiempo = t.mostrar_tiempo()
print tiempo
sleep(0.5)
if tiempo == "00 : 00 : 00":
break
t.retroceder()
while True:
tiempo = t.mostrar_tiempo()
print tiempo
sleep(0.5)
if tiempo == "00 : 00 : 15":
break
t.avanzar()
def finalizar_tiempo_de_ejecucion(self):
self.datetime_final = Temporizador.obtener_fecha_tiempo_actual()
self.tiempo_fin_de_ejecucion = Temporizador.obtener_tiempo_timer()
self.establecer_tiempo_de_ejecucion()
def crear_timer(self):
self.timer = Temporizador(x=420, y=220)
self.timer.setDatas(self.usuarios[self.nombre]['tiempo'])
self.timer.iniciar()
pilas.mundo.agregar_tarea_siempre(1, self.timer_preguntar)
def navegacion_de_carpetas_por_segundos(lista_carpetas,
driver,
result_list,
numero_de_segundos=120):
result_navegacion_carpetas = Result()
result_navegacion_carpetas.inicializar_tiempo_de_ejecucion()
tiempo_por_verificar = numero_de_segundos + Temporizador.obtener_tiempo_timer(
)
tiempo_de_inicio = Temporizador.obtener_tiempo_timer()
segundos = 0
# verifica se tenga al menos una carpeta
if len(lista_carpetas) == 0:
result_navegacion_carpetas.finalizar_tiempo_de_ejecucion()
result_navegacion_carpetas.establecer_tiempo_de_ejecucion()
result_navegacion_carpetas.validacion_correcta = False
result_navegacion_carpetas.mensaje_error = 'No fue posible localizar las carpetas dentro de la sesi\u00f3n Exchange OWA'
result_list.result_validacion_navegacion_carpetas = result_navegacion_carpetas
SeleniumTesting.log.info(
'No se localizaron carpetas por navegar dentro de la sesion en la plataforma Exchange OWA'
)
return result_list
# verifica que no haya algun mensaje de error en la plataforma, en caso contrario
# se muestra el mensaje de error que aparace en la plataforma dentro del result
elif SeleniumTesting.verificar_error_plataforma(driver):
result_navegacion_carpetas.finalizar_tiempo_de_ejecucion()
result_navegacion_carpetas.establecer_tiempo_de_ejecucion()
result_navegacion_carpetas.validacion_correcta = False
result_navegacion_carpetas.mensaje_error = 'No fue posible realizar la navegacion entre carpetas, se presenta '\
'el siguiente error dentro de la plataforma: '\
'{}'.format(SeleniumTesting.txt_mensaje_error_encontrado_owa)
result_list.result_validacion_navegacion_carpetas = result_navegacion_carpetas
return result_list
while Temporizador.obtener_tiempo_timer() <= tiempo_por_verificar:
for carpeta in lista_carpetas:
segundos = Temporizador.obtener_tiempo_timer(
) - tiempo_de_inicio
if segundos > numero_de_segundos:
SeleniumTesting.log.info(
'Ha transcurrido un lapso aproximado de 2 minutos, se procede a cerrar la sesion dentro de la plataforma OWA'
)
break
SeleniumTesting.log.info(
'Ingresando a la carpeta: {}'.format(carpeta))
try:
if SeleniumTesting.owa_descubierto == 2016:
script_click_carpeta = \
'''
var carpeta = document.querySelector("span._n_C4[title='{}']");
return carpeta;
'''.format(carpeta)
elemento_html_carpeta = driver.execute_script(
script_click_carpeta)
elemento_html_carpeta.click()
time.sleep(6)
elif SeleniumTesting.owa_descubierto == 2010:
elemento_html_carpeta = driver.find_element_by_xpath(
'//a[@name="lnkFldr"][@title="{}"]'.format(
carpeta))
time.sleep(3)
SeleniumTesting.verificar_dialogo_de_interrupcion(
driver, result_navegacion_carpetas)
time.sleep(3)
elemento_html_carpeta.click()
elif SeleniumTesting.owa_descubierto == 2013:
script_click_carpeta = \
'''
var carpeta = document.querySelector("span._n_Z6[title='{}']");
return carpeta;
'''.format(carpeta)
elemento_html_carpeta = driver.execute_script(
script_click_carpeta)
elemento_html_carpeta.click()
time.sleep(6)
except StaleElementReferenceException as e:
SeleniumTesting.log.error(
'Una de las carpetas no se localiza dentro del DOM de la plataforma OWA, se intentara ingresar nuevamente'
)
SeleniumTesting.log.error('error: {}'.format(e.msg))
driver.refresh()
SeleniumTesting.log.error(
'Sucedio error al refrescar la plataforma OWA')
time.sleep(3)
except ElementClickInterceptedException as e:
SeleniumTesting.log.error(
'No fue posible navegar a la carpeta seleccionada, se tiene un elemento HTML interfiriendo en la '\
'navegacion de la carpeta, se intentara ingresar nuevamente')
SeleniumTesting.log.error('error: {}'.format(e.msg))
driver.refresh()
SeleniumTesting.log.error(
'Sucedio error al refrescar la plataforma OWA')
time.sleep(3)
except NoSuchElementException as e:
SeleniumTesting.log.error(
'No fue posible localizar la carpeta por navegar dentro de la plataforma OWA, se intentara ingresar nuevamente'
)
SeleniumTesting.log.error('error: {}'.format(e.msg))
driver.refresh()
SeleniumTesting.log.error(
'Sucedio error al refrescar la plataforma OWA')
time.sleep(3)
except TimeoutException as e:
SeleniumTesting.log.error(
'Se presenta error de tiempo de carga en la plataforma OWA, se intentara actualizar la plataforma nuevamente'
)
SeleniumTesting.log.error('error: {}'.format(e.msg))
driver.refresh()
time.sleep(3)
except WebDriverException as e:
SeleniumTesting.log.error(
'Se presenta error del webdriver para la navegacion web dentro de la plataforma OWA'
)
SeleniumTesting.log.error('error: {}'.format(e.msg))
time.sleep(3)
result_navegacion_carpetas.finalizar_tiempo_de_ejecucion()
result_navegacion_carpetas.establecer_tiempo_de_ejecucion()
# verifica que no haya algun mensaje de error en la plataforma, en caso contrario
# se muestra el mensaje de error que aparace en la plataforma dentro del result
if SeleniumTesting.verificar_error_plataforma(driver):
result_navegacion_carpetas.validacion_correcta = False
result_navegacion_carpetas.mensaje_error = 'No fue posible realizar la navegacion entre carpetas, se presenta '\
'el siguiente error dentro de la plataforma: '\
'{}'.format(SeleniumTesting.txt_mensaje_error_encontrado_owa)
else:
result_navegacion_carpetas.validacion_correcta = True
result_navegacion_carpetas.mensaje_error = constantes_json.OUTPUT_EXITOSO_2_1
result_list.result_validacion_navegacion_carpetas = result_navegacion_carpetas
return result_list
def obtener_carpetas_en_sesion(driver):
lista_de_carpetas_localizadas = []
lista_nombres_de_carpetas_formateadas = []
clase_css_carpeta_owa_2016 = "_n_C4"
clase_css_carpeta_owa_2013 = '_n_Z6'
xpath_carpeta_owa_2010 = "//a[@name='lnkFldr']"
se_encontraron_carpetas = False
tiempo_de_inicio = Temporizador.obtener_tiempo_timer()
tiempo_de_finalizacion = 0
while tiempo_de_finalizacion < 60:
time.sleep(10)
if SeleniumTesting.verificar_elemento_encontrado_por_clase_js(
driver, clase_css_carpeta_owa_2016):
SeleniumTesting.owa_descubierto = 2016
se_encontraron_carpetas = True
elif SeleniumTesting.verificar_elemento_encontrado_por_clase_js(
driver, clase_css_carpeta_owa_2013):
SeleniumTesting.owa_descubierto = 2013
se_encontraron_carpetas = True
elif SeleniumTesting.verificar_elemento_encontrado_por_xpath(
driver, xpath_carpeta_owa_2010):
SeleniumTesting.owa_descubierto = 2010
se_encontraron_carpetas = True
tiempo_de_finalizacion = Temporizador.obtener_tiempo_timer(
) - tiempo_de_inicio
if tiempo_de_finalizacion % 20 == 0:
SeleniumTesting.navegar_a_sitio(
SeleniumTesting.url_owa_exchange)
driver.refresh()
if se_encontraron_carpetas:
SeleniumTesting.log.info('Se localizan con exito las carpetas dentro de la plataforma OWA, en un lapso aproximado'\
' de {} seg'.format(FormatUtils.truncar_float_cadena(tiempo_de_finalizacion)))
break
else:
SeleniumTesting.log.info(
'Fue imposible localizar las carpetas dentro de la plataforma OWA, se intentara nuevamente'
)
SeleniumTesting.log.info(
'Titulo actual de la plataforma: {}'.format(driver.title))
SeleniumTesting.log.info(
'URL actual de la plataforma: {}'.format(
driver.current_url))
if se_encontraron_carpetas == False:
tiempo_de_finalizacion = Temporizador.obtener_tiempo_timer(
) - tiempo_de_inicio
SeleniumTesting.log.error('Han transcurrido mas de {} seg sin localizar'\
' las carpetas dentro de la plataforma OWA'.format(FormatUtils.truncar_float_cadena(tiempo_de_finalizacion)))
SeleniumTesting.log.error(
'Title actual de la plataforma: {}'.format(driver.title))
SeleniumTesting.log.error('Url actual de la plataforma: {}'.format(
driver.current_url))
else:
SeleniumTesting.log.info(
'Plataforma OWA version {} identificada'.format(
SeleniumTesting.owa_descubierto))
time.sleep(4)
if SeleniumTesting.owa_descubierto == 2010:
lista_de_carpetas_localizadas = driver.find_elements_by_xpath(
xpath_carpeta_owa_2010)
elif SeleniumTesting.owa_descubierto == 2013:
script_js = '''
var elementos = document.getElementsByClassName('_n_Z6');
return elementos;
'''
lista_de_carpetas_localizadas = driver.execute_script(
script_js)
elif SeleniumTesting.owa_descubierto == 2016:
script_js = '''
var elementos = document.getElementsByClassName('_n_C4');
return elementos;
'''
lista_de_carpetas_localizadas = driver.execute_script(
script_js)
for carpeta in lista_de_carpetas_localizadas:
if SeleniumTesting.owa_descubierto == 2010:
nombre_de_carpeta = carpeta.text
else:
nombre_de_carpeta = FormatUtils.remover_backspaces(
carpeta.get_attribute('innerHTML'))
SeleniumTesting.log.info(
'Se obtiene la carpeta: {}'.format(nombre_de_carpeta))
lista_nombres_de_carpetas_formateadas.append(nombre_de_carpeta)
return lista_nombres_de_carpetas_formateadas
def iniciar_sesion_en_owa(driver, correo_en_prueba, result_list):
# verificacion en texto de mensajes de error en inicio de sesion
error_security_context = 'NegotiateSecurityContext'
# se obtiene la cuenta sin el origen del dominio
SeleniumTesting.cuenta_sin_dominio = FormatUtils.formatear_correo(
correo_en_prueba.correo)
SeleniumTesting.url_owa_exchange = correo_en_prueba.url
#xpath de botones owa 2010, 2016, 2013
xpath_btn_owa_2010 = "//input[@type='submit'][@class='btn']"
xpath_btn_owa_2013_2016 = "//div[@class='signinbutton']"
driver.accept_insecure_certs = True
driver.accept_untrusted_certs = True
resultado = Result()
resultado.tiempo_inicio_de_ejecucion = Temporizador.obtener_tiempo_timer(
)
resultado.datetime_inicial = Temporizador.obtener_fecha_tiempo_actual()
# resultado.inicializar_tiempo_de_ejecucion()
mensaje_error_de_credenciales = None
try:
# obtiene los elementos html para los campos de usuario, password y el boton de inicio de
# sesion
time.sleep(3)
input_usuario = driver.find_element_by_id('username')
input_password = driver.find_element_by_id('password')
check_casilla_owa_2010_version_ligera = None
boton_ingreso_correo = None
# verifica si se encuentra la casilla con el id chkBsc, el cual pertenece a la version
# ligera de la plataforma de Exchange 2010
if SeleniumTesting.verificar_elemento_encontrado_por_id(
driver, 'chkBsc'):
# selecciona el check para ingresar a la plataforma ligera
check_casilla_owa_2010_version_ligera = driver.find_element_by_id(
'chkBsc')
check_casilla_owa_2010_version_ligera.click()
SeleniumTesting.owa_descubierto = 2010
if SeleniumTesting.verificar_elemento_encontrado_por_xpath(
driver, xpath_btn_owa_2010):
boton_ingreso_correo = driver.find_element_by_xpath(
xpath_btn_owa_2010)
SeleniumTesting.owa_descubierto = 2010
elif SeleniumTesting.verificar_elemento_encontrado_por_xpath(
driver, xpath_btn_owa_2013_2016):
boton_ingreso_correo = driver.find_element_by_xpath(
xpath_btn_owa_2013_2016)
# establece la bandera version owa por analizar
SeleniumTesting.owa_descubierto = 2016
# ingresa los datos en cada uno de los inputs localizados en el sitio de owa, uno por
# cada segundo
time.sleep(1)
input_usuario.send_keys(correo_en_prueba.correo)
time.sleep(1)
input_password.send_keys(correo_en_prueba.password)
time.sleep(1)
boton_ingreso_correo.click()
time.sleep(18)
SeleniumTesting.log.info(
'Titulo actual de la plataforma: {}'.format(driver.title))
SeleniumTesting.log.info('URL actual de la plataforma: {}'.format(
driver.current_url))
except NoSuchElementException as e:
resultado.mensaje_error = 'No fue posible iniciar sesion dentro de la plataforma OWA, '\
'no se localizaron los inputs para ingresar las credenciales de la cuenta '\
'de correo electronico Exchange: {}'.format(SeleniumTesting.formatear_excepcion(e))
resultado.validacion_correcta = False
SeleniumTesting.log.error(resultado.mensaje_error)
except WebDriverException as e:
resultado.mensaje_error = 'No fue posible ingresar a la plataforma de Exchange OWA, favor de verificar'\
' si se tiene conectividad por internet, error detallado : {}'.format(SeleniumTesting.formatear_excepcion(e))
resultado.validacion_correcta = False
SeleniumTesting.log.error(resultado.mensaje_error)
# verifica que se haya ingresado correctamente al OWA, se localiza si esta establecido
# el mensaje de error de credenciales dentro del aplicativo del OWA
if resultado.validacion_correcta == False:
try:
if SeleniumTesting.owa_descubierto == 2010:
mensaje_error_de_credenciales = driver.find_element_by_id(
'trInvCrd')
SeleniumTesting.log.error(
'No fue posible ingresar a la plataforma OWA, se tiene error de credenciales'
)
mensaje_error_de_credenciales = driver.find_element_by_xpath(
"//tr[@id='trInvCrd']/td")
texto_mensaje_error = mensaje_error_de_credenciales.get_attribute(
'innerHTML')
SeleniumTesting.log.error('Se muestra el siguiente mensaje de error de credenciales: {} '\
.format(texto_mensaje_error))
resultado.mensaje_error = 'No fue posible ingresar a la plataforma OWA, se tiene error de credenciales: {}'\
.format(mensaje_error_de_credenciales.get_attribute('innerHTML'))
resultado.validacion_correcta = False
elif SeleniumTesting.owa_descubierto == 2016 or SeleniumTesting.owa_descubierto == 2013:
mensaje_error_de_credenciales = driver.execute_script('''
var mensaje_error = document.querySelector("#signInErrorDiv").innerText;
return mensaje_error;
''')
SeleniumTesting.log.error(
'No se puede ingresar al aplicativo debido a error de credenciales:'
)
SeleniumTesting.log.error('Se muestra el siguiente mensaje de advertencia: {} '\
.format(mensaje_error_de_credenciales))
resultado.mensaje_error = 'No fue posible ingresar a la plataforma OWA, se tiene error de credenciales: '\
'{}'.format(mensaje_error_de_credenciales)
resultado.validacion_correcta = False
except NoSuchElementException as e:
resultado.mensaje_error = constantes_json.OUTPUT_EXITOSO_1_1
resultado.validacion_correcta = True
SeleniumTesting.log.info(resultado.mensaje_error)
except InvalidSessionIdException as e:
resultado.mensaje_error = 'No fue posible ingresar a la plataforma de Exchange OWA, favor de verificar '\
'si se tiene conectividad por internet, error detallado : {}'.format(e)
resultado.validacion_correcta = False
SeleniumTesting.log.error(resultado.mensaje_error)
except JavascriptException as e:
# Se ingresa correctamente, debido a que no se encontro el mensaje de error de credenciales incorrectas
resultado.mensaje_error = constantes_json.OUTPUT_EXITOSO_1_1
resultado.validacion_correcta = True
SeleniumTesting.log.info(resultado.mensaje_error)
except WebDriverException as e:
# Se ingresa correctamente, debido a que no se encontro el mensaje de error de credenciales incorrectas
resultado.mensaje_error = constantes_json.OUTPUT_EXITOSO_1_1
resultado.validacion_correcta = True
SeleniumTesting.log.info(resultado.mensaje_error)
# realiza la validacion de ingreso correcto de sesion
# se verifica que no haya algun error que se presente en la plataforma
# en caso contrario se obtiene el mensaje del error y se establecer en el
# objeto resultado
if SeleniumTesting.verificar_error_plataforma(driver):
resultado.mensaje_error = 'No fue posible ingresar a la sesion, se presenta '\
'el siguiente mensaje de error en la plataforma: {}'.format(SeleniumTesting.txt_mensaje_error_encontrado_owa)
resultado.validacion_correcta = False
resultado.finalizar_tiempo_de_ejecucion()
resultado.establecer_tiempo_de_ejecucion()
result_list.result_validacion_acceso_portal_owa = resultado
return result_list
class Adivinanza(Base):
def __init__(self,nombre='',datos = ''):
Base.__init__(self)
self.nombre = nombre
self.datos = datos
def iniciar(self):
self.fondo()
self.interfaz()
self.generar()
def fondo(self):
pilas.fondos.Fondo("data/img/fondos/adivinanza.jpg")
def interfaz(self):
#Timer
self.time = Temporizador(x=-250,y=300)
self.time.setDatas(0)
self.time.iniciar_aum()
#Titulo
self.texto_titulo = pilas.actores.Actor("data/img/enunciados/adivinanza.png",y=270)
self.texto_titulo.escala = 0.5
#Recuadro
self.recuadro = pilas.actores.Actor("data/img/interfaz/recuadrito.png",x = -20,y = 50)
self.recuadro.escala = 0.4
#Personaje
self.personaje = pilas.actores.Actor("data/img/iconos/character.png",y=-150)
self.personaje.escala = 0.26
self.personaje.decir("Clickea en el animal al que hace referencia la adivinanza") ###dialogo
#Adivinanza
numero = random.randrange(0,6)
self.adivinanza = adivinanzas[numero]
self.texto = pilas.actores.Texto(self.adivinanza,fuente="data/fonts/American Captain.ttf", y = 50 , ancho = 256 )
self.texto.color = pilas.colores.negro
def generar(self):
self.lista_elemento = []
coor = [(-300,0),(280,-200),(280,200),(280,0),(-280,-200),(-280,200)]
for x in range(len(lista)):
self.elemento = Animal(x=coor[x][0],y=coor[x][1],imagen=lista[x])
self.elemento.escala = 0.6
self.lista_elemento.append(self.elemento)
self.elemento.activar()
self.elemento.conectar_presionado(self.verificar, arg=x)
def verificar(self,x):
self.elemento = self.lista_elemento[x]
seleccion = self.elemento.getElemento()
if(lista.index(seleccion)== adivinanzas.index(self.adivinanza)):
self.personaje.decir("Bien hecho , ganaste un rayo de energia")
self.ener = True
else:
self.personaje.decir("Respuesta incorrecta , perdiste un rayo")
self.ener = False
pilas.mundo.agregar_tarea(2,self.volver)
def volver(self):
self.time.stopTimer()
self.datos[self.nombre]['tiempo_adivinanza'][0] = self.datos[self.nombre]['tiempo_adivinanza'][0] + self.time.getTime()
self.datos[self.nombre]['tiempo_adivinanza'][1] = self.datos[self.nombre]['tiempo_adivinanza'][1] + 1
if(self.ener == False):
self.datos[self.nombre]['tiempo_adivinanza'][2] = self.datos[self.nombre]['tiempo_adivinanza'][2] + 1
f = open("data/archivos/estadisticas.json","w")
f.write(json.dumps(self.datos))
f.close()
e = open("data/archivos/energia.txt",'wb')
pickle.dump(self.ener,e)
e.close()
pilas.recuperar_escena()
Fs = 2.048e6
parser = argparse.ArgumentParser(description='Procesar N muestras de FM.')
parser.add_argument('-n', action='store', dest='N',help='numero de muestras ej:1024e4',type=float,default=1024e4)
parser.add_argument('-f', action='store', dest='Fo',help='frecuencia centro en MHz ej:91.3',type=float,default=91.3)
parser.add_argument('--plot', action='store_true', default=False,dest='plot',help='Mostrar graficos de DEP y FFT')
args = parser.parse_args()
sdr = RtlSdr()
sdr.sample_rate = Fs # Hz
sdr.center_freq = (args.Fo*1e6) # Hz
sdr.freq_correction = 60 # PPM
sdr.gain = 'auto'
timer = Temporizador()
plotter = Plotter(Fs,(args.Fo*1e6)) if args.plot else None
fm = Demodulador(timer,plotter = plotter)
sFs = fm.outputFs()
timer.tag('inicio toma de muestras')
samples = sdr.read_samples(args.N)
timer.tag('fin toma de muestras')
audio = fm.demodular(samples)
timer.tag('reproduciendo audio')
sd.play(audio,sFs,blocking=True)
def establecer_tiempo_de_finalizacion(objeto_json):
objeto_json['time'] = Temporizador.obtener_tiempo_timer()
# objeto_json['status'] = constantes_json.STATUS_CORRECTO
objeto_json['end'] = Temporizador.obtener_fecha_tiempo_actual()
return objeto_json
def inicializar_tiempo_de_ejecucion(self):
self.datetime_inicial = Temporizador.obtener_fecha_tiempo_actual()
self.tiempo_inicio_de_ejecucion = Temporizador.obtener_tiempo_timer()
class Tablero(Base):
def __init__(self, nombre, musica):
Base.__init__(self)
self.nombre = nombre
self.musica = musica
self.energia = 3
def fondo(self):
pilas.fondos.Fondo('data/img/fondos/tablero_img.png')
def escena_ayuda(self):
self.sonido_boton.reproducir()
pilas.almacenar_escena(Ayuda())
def act(self):
self.dado.activar()
self.boton.activar()
self.ayuda.activar()
def des(self):
self.dado.desactivar()
self.boton.desactivar()
self.ayuda.desactivar()
def regresar(self):
self.sonido_boton.reproducir()
self.musicaa.solo_detener()
musica = open("data/archivos/musica.txt", 'rb')
self.estado = pickle.load(musica)
musica.close()
pilas.mundo.deshabilitar_sonido(False)
if (self.estado == True):
self.musica.encender()
elif (self.estado == False):
self.musica.apagar()
pilas.recuperar_escena()
def volver(self):
def continuar():
self.sonido_boton.reproducir()
self.text1.eliminar()
self.si.eliminar()
self.no.eliminar()
self.cartel.eliminar()
self.act()
self.timer.continuar()
def crear_texto():
self.text1 = pilas.actores.Texto(
"Esta seguro que desea salir?",
fuente="data/fonts/American Captain.ttf",
y=100)
self.si = pilas.actores.Boton(y=-35)
self.si.definir_imagen('data/img/interfaz/si.png')
self.si.escala = 0.7
self.no = pilas.actores.Boton(y=-165)
self.no.definir_imagen('data/img/interfaz/no.png')
self.no.escala = 0.7
self.si.conectar_presionado(self.regresar)
self.no.conectar_presionado(continuar)
self.sonido_boton.reproducir()
self.timer.stopTimer()
self.des()
self.cartel = pilas.actores.Actor('data/img/iconos/cartel.png')
self.cartel.escala = [1.8, 1], 0.8
pilas.mundo.agregar_tarea(1, crear_texto)
def cargar_sonidos(self):
self.sonido_boton = pilas.sonidos.cargar("data/audio/boton.ogg")
self.sonido_dado = pilas.sonidos.cargar("data/audio/dice.ogg")
self.sonido_teleport = pilas.sonidos.cargar("data/audio/teleport.ogg")
self.sonido_vida = pilas.sonidos.cargar("data/audio/pierde_vida.ogg")
self.gana_energia = pilas.sonidos.cargar("data/audio/gana_energia.ogg")
self.pierde_energia = pilas.sonidos.cargar(
"data/audio/pierde_energia.ogg")
self.gana_partida = pilas.sonidos.cargar("data/audio/victoria.ogg")
self.pierde_partida = pilas.sonidos.cargar("data/audio/derrota.ogg")
def iniciar(self):
self.fondo()
archivo = open('data/archivos/usuarios.json', 'r')
self.usuarios = json.load(archivo)
archivo.close()
archivo1 = open('data/archivos/estadisticas.json', 'r')
self.datos = json.load(archivo1)
archivo1.close()
self.estado = True
self.cargar_sonidos()
self.crear_tablero()
self.iniciar_personaje()
self.crear_interfaz()
self.casillero_actual = casillero_mapa
self.camino_actual = camino_1
def iniciar_sonido(self):
musica = open("data/archivos/musica.txt", 'rb')
est = pickle.load(musica)
musica.close()
self.music = pilas.sonidos.cargar(
"data/audio/Enchanted Festival Loop.ogg")
if est:
self.music.reproducir(repetir=True)
self.musicaa = Sonido(musica=self.music,
x=-445,
y=-190,
estado=est,
imagen1="data/img/interfaz/on1.png",
imagen2="data/img/interfaz/off1.png")
def crear_interfaz(self):
self.iniciar_sonido()
self.boton = pilas.actores.Boton(x=-450, y=-313)
self.boton.definir_imagen('data/img/interfaz/atras.png')
self.boton.escala = 0.09
self.boton.conectar_presionado(self.volver)
self.ayuda = pilas.actores.Boton(x=-445, y=-250)
self.ayuda.definir_imagen('data/img/interfaz/ayuda.png')
self.ayuda.escala = 0.2
self.ayuda.conectar_presionado(self.escena_ayuda)
def crear_tablero(self):
self.mapa()
self.castillo()
self.flechas()
self.crear_casilleros()
self.titulo_vidas = pilas.actores.Texto(
"VIDAS:", fuente="data/fonts/American Captain.ttf", x=355, y=332)
self.crear_vidas()
self.titulo_energia = pilas.actores.Texto(
"ENERGIA:", fuente="data/fonts/American Captain.ttf", x=369, y=260)
self.crear_energia()
self.titulo_tiempo = pilas.actores.Texto(
"TIEMPO:", fuente="data/fonts/American Captain.ttf", x=369, y=220)
self.crear_timer()
self.dado = Dado(x=-110, y=134)
self.dado.conectar_presionado(self.tirar_dado)
def crear_timer(self):
self.timer = Temporizador(x=420, y=220)
self.timer.setDatas(self.usuarios[self.nombre]['tiempo'])
self.timer.iniciar()
pilas.mundo.agregar_tarea_siempre(1, self.timer_preguntar)
def timer_preguntar(self):
if (self.timer.getTime() == 0):
self.perdio()
def _cont_energia(self):
num = 'x' + str(self.energia)
self.contador_energia = pilas.actores.Texto(
num, fuente="data/fonts/American Captain.ttf", x=460, y=260)
def crear_energia(self):
#Rayo
self.rayo = pilas.actores.Actor('data/img/iconos/rayo.png',
x=430,
y=260)
self.rayo.escala = 0.050
#Energia
self._cont_energia()
def crear_vidas(self):
#Vida 1
self.vida1 = pilas.actores.Actor('data/img/iconos/corazon.png')
self.vida1.escala = 0.050
self.vida1.x = 350
self.vida1.y = 300
#Vida 2
self.vida2 = pilas.actores.Actor('data/img/iconos/corazon.png')
self.vida2.escala = 0.050
self.vida2.x = 390
self.vida2.y = 300
#Vida 3
self.vida3 = pilas.actores.Actor('data/img/iconos/corazon.png')
self.vida3.escala = 0.050
self.vida3.x = 430
self.vida3.y = 300
self.vidas = 3
def iniciar_personaje(self):
self.personaje = pilas.actores.Actor('data/img/iconos/character.png')
self.personaje.escala = 0.2
self.personaje.x = casillero_mapa[0]
self.personaje.y = casillero_mapa[1]
self.personaje.decir("Hola! Empecemos a jugar!")
def flechas(self):
#Flecha 1
self.flecha1 = pilas.actores.Actor(
'data/img/interfaz/flecha_arriba.png', x=-338, y=-62)
self.flecha1.escala = 0.040
#Flecha 2
self.flecha2 = pilas.actores.Actor(
'data/img/interfaz/flecha_arriba.png', x=-182, y=-59)
self.flecha2.escala = 0.040
#Flecha 3
self.flecha3 = pilas.actores.Actor(
'data/img/interfaz/flecha_arriba.png', x=132, y=-58)
self.flecha3.escala = 0.040
#Flecha 4
self.flecha4 = pilas.actores.Actor(
'data/img/interfaz/flecha_abajo.png', x=-184, y=-251)
self.flecha4.escala = 0.050
def castillo(self):
self.casti = pilas.actores.Actor('data/img/iconos/castillo.png',
x=-365,
y=315)
self.casti.escala = 0.11
def mapa(self):
self.mapita = pilas.actores.Actor('data/img/iconos/mapa.png',
x=391,
y=-325)
self.mapita.escala = 0.08
def crear_casilleros(self):
self.casi_tele = []
self.casi = casilleros[:]
self.imagenes_posiciones = casilleros[:]
self.imagenes = {
"data/img/iconos/Casillero.png":
self.usuarios[self.nombre]['casillero_normal'],
"data/img/iconos/CasilleroVioleta.png":
self.usuarios[self.nombre]['casillero_violeta'],
"data/img/iconos/CasilleroNaranja.png":
self.usuarios[self.nombre]['casillero_naranja'],
"data/img/iconos/CasilleroVerde.png":
self.usuarios[self.nombre]['casillero_verde'],
"data/img/iconos/ahorcado.png":
4,
"data/img/iconos/Casillero_comodin.png":
4,
"data/img/iconos/pare.png":
4,
"data/img/iconos/perder_vida.png":
4,
"data/img/iconos/teletransportacion.png":
4
}
for x in range(0, len(casilleros_bifurcacion)):
casillero = pilas.actores.Actor("data/img/iconos/bifurcacion.png")
casillero.escala = 0.055
casillero.x = casilleros_bifurcacion[x][0]
casillero.y = casilleros_bifurcacion[x][1]
for x in self.imagenes.keys():
for i in range(0, self.imagenes[x]):
casillero = pilas.actores.Actor(x)
self.posi = random.randrange(0, len(self.casi))
casille = self.casi[self.posi]
self.casi.remove(casille)
self.imagenes_posiciones[self.imagenes_posiciones.index(
casille)] = x
casillero.x = casille[0]
casillero.y = casille[1]
casillero.escala = 0.09
if (x == "data/img/iconos/teletransportacion.png"):
tele = (casillero.x, casillero.y)
self.casi_tele.append(tele)
self.guardar_imagenes()
def guardar_imagenes(self):
datos = open("data/archivos/imagenes.json", 'w')
elementos = {
"imagenes": self.imagenes_posiciones,
"casilleros": casilleros
}
datos.write(json.dumps(elementos))
datos.close()
def actualizar_energia(self):
archivo_energia = open('data/archivos/energia.txt', 'rb')
boolean = pickle.load(archivo_energia)
archivo_energia.close()
self.contador_energia.eliminar()
if (boolean == True):
self.energia = self.energia + 1
self.gana_energia.reproducir()
else:
self.energia = self.energia - 1
self.pierde_energia.reproducir()
self._cont_energia()
if (self.energia == 0):
self.perder_vida()
def ver_est(self):
if self.estado:
self.musicaa.encender()
def desactivar_sonido(self):
musica = open("data/archivos/musica.txt", 'rb')
self.estado = pickle.load(musica)
musica.close()
if self.estado:
self.musicaa.apagar()
pilas.mundo.deshabilitar_sonido(False)
def gano(self):
self.des()
self.guardar_tiempo()
self.gana_partida.reproducir()
pantalla1 = pilas.actores.Actor('data/img/fondos/trono.jpg')
titulo1 = pilas.actores.Actor('data/img/enunciados/victoria.png')
titulo1.escala = 0.5
self.boton1 = pilas.actores.Boton(x=-420, y=-300)
self.boton1.definir_imagen('data/img/interfaz/atras.png')
self.boton1.escala = 0.1
self.boton1.conectar_presionado(self.regresar)
def perdio(self):
self.des()
self.guardar_tiempo()
self.pierde_partida.reproducir()
pantalla = pilas.actores.Actor('data/img/fondos/derrota.jpg')
titulo_perdio = pilas.actores.Actor("data/img/enunciados/derrota.png")
titulo_perdio.escala = 0.5
self.boton2 = pilas.actores.Boton(x=-420, y=-300)
self.boton2.definir_imagen('data/img/interfaz/atras.png')
self.boton2.escala = 0.1
self.boton2.conectar_presionado(self.regresar)
def perder_vida(self):
self.sonido_vida.reproducir()
self.contador_energia.eliminar()
if (self.vidas == 3):
self.vida3.eliminar()
self.vidas -= 1
self.energia = 3
self._cont_energia()
elif (self.vidas == 2):
self.vida2.eliminar()
self.vidas -= 1
self.energia = 3
self._cont_energia()
elif (self.vidas == 1):
self.des()
self.energia = 0
self._cont_energia()
self.vida1.eliminar()
self.perdio()
def teletransportacion(self):
self.sonido_teleport.reproducir()
self.personaje.escala = [0.4, 0.2], 1.5
casillero_tele = random.choice(self.casi_tele)
self.casillero_actual = casillero_tele
if (self.casillero_actual in camino_1):
self.camino_actual = camino_1
elif (self.casillero_actual in camino_2):
self.camino_actual = camino_2
elif (self.casillero_actual in camino_3):
self.camino_actual = camino_3
elif (self.casillero_actual in camino_4):
self.camino_actual = camino_4
elif (self.casillero_actual in camino_5):
self.camino_actual = camino_5
elif (self.casillero_actual in camino_6):
self.camino_actual = camino_6
elif (self.casillero_actual in camino_7):
self.camino_actual = camino_7
elif (self.casillero_actual in camino_8):
self.camino_actual = camino_8
self.personaje.x = self.casillero_actual[0]
self.personaje.y = self.casillero_actual[1]
self.personaje.escala = [0.3, 0.2], 1.5
def retroceder(self):
i = self.camino_actual.index(self.casillero_actual) - 1
self.casillero_actual = self.camino_actual[i]
self.personaje.x = [self.casillero_actual[0]]
self.personaje.y = [self.casillero_actual[1]]
#Parches para que funcione al caer en una bifurcacion
if (self.casillero_actual in camino_2) and (self.camino_actual.index(
self.casillero_actual) < 1):
self.casillero_actual = (self.casillero_actual[0],
self.casillero_actual[1] + 1)
if (self.casillero_actual in camino_3) and (self.camino_actual.index(
self.casillero_actual) < 1):
self.casillero_actual = (self.casillero_actual[0],
self.casillero_actual[1] - 1)
if (self.casillero_actual in camino_4) and (self.camino_actual.index(
self.casillero_actual) < 1):
self.casillero_actual = (self.casillero_actual[0],
self.casillero_actual[1] + 1)
if (self.casillero_actual in camino_5) and (self.camino_actual.index(
self.casillero_actual) < 1):
self.casillero_actual = (self.casillero_actual[0] + 1,
self.casillero_actual[1])
if (self.casillero_actual in camino_6) and (self.camino_actual.index(
self.casillero_actual) < 1):
self.casillero_actual = (self.casillero_actual[0] - 1,
self.casillero_actual[1])
if (self.casillero_actual in camino_7) and (self.camino_actual.index(
self.casillero_actual) < 1):
self.casillero_actual = (self.casillero_actual[0] - 1,
self.casillero_actual[1])
if (self.casillero_actual in camino_8) and (self.camino_actual.index(
self.casillero_actual) < 1):
self.casillero_actual = (self.casillero_actual[0] + 1,
self.casillero_actual[1])
self.preguntar_accion()
def guardar_tiempo(self):
self.timer.stopTimer()
self.tiempo_pasado = self.timer.getTime()
self.datos[self.nombre]["tiempo"] = self.tiempo_pasado
self.datos[self.nombre]["rayos"] = self.energia
archivo = open('data/archivos/estadisticas.json', 'w')
archivo.write(json.dumps(self.datos))
archivo.close()
def preguntar(self):
def borrar1():
self.izquierda.desactivar()
self.izquierda.destruir()
self.derecha.desactivar()
self.derecha.destruir()
self.cartel_bifurcacion.destruir()
self.act()
def borrar2():
self.arriba.desactivar()
self.arriba.destruir()
self.izquierda.desactivar()
self.izquierda.destruir()
self.cartel_bifurcacion.destruir()
self.act()
def borrar3():
self.arriba.desactivar()
self.arriba.destruir()
self.abajo.desactivar()
self.abajo.destruir()
self.cartel_bifurcacion.destruir()
self.act()
def bifurcacion1_izquierda():
self.camino_actual = camino_1
self.casillero_actual = self.camino_actual[0]
borrar1()
def bifurcacion1_derecha():
self.camino_actual = camino_2
self.casillero_actual = self.camino_actual[0]
borrar1()
def bifurcacion2_arriba():
self.camino_actual = camino_3
self.casillero_actual = self.camino_actual[0]
borrar2()
def bifurcacion2_izquierda():
self.camino_actual = camino_4
self.casillero_actual = self.camino_actual[0]
borrar2()
def bifurcacion3_arriba():
self.camino_actual = camino_7
self.casillero_actual = self.camino_actual[0]
borrar2()
def bifurcacion3_izquierda():
self.camino_actual = camino_8
self.casillero_actual = self.camino_actual[0]
borrar2()
def bifurcacion4_arriba():
self.camino_actual = camino_5
self.casillero_actual = self.camino_actual[0]
borrar3()
def bifurcacion4_abajo():
self.camino_actual = camino_6
self.casillero_actual = self.camino_actual[0]
borrar3()
self.cartel_bifurcacion = pilas.actores.Actor(
'data/img/iconos/cartel_bifurcacion.png', x=8, y=100)
self.cartel_bifurcacion.escala = 1
if (self.casillero_actual == (391, -265)):
self.izquierda = pilas.actores.Boton(x=10, y=175)
self.izquierda.definir_imagen('data/img/interfaz/izquierda.png')
self.izquierda.escala = 0.5
self.derecha = pilas.actores.Boton(x=10, y=120)
self.derecha.definir_imagen('data/img/interfaz/derecha.png')
self.derecha.escala = 0.5
self.izquierda.conectar_presionado(bifurcacion1_izquierda)
self.derecha.conectar_presionado(bifurcacion1_derecha)
if (self.casillero_actual == (131, -148)):
self.arriba = pilas.actores.Boton(x=10, y=175)
self.arriba.definir_imagen('data/img/interfaz/arriba.png')
self.arriba.escala = 0.5
self.izquierda = pilas.actores.Boton(x=10, y=120)
self.izquierda.definir_imagen('data/img/interfaz/izquierda.png')
self.izquierda.escala = 0.5
self.arriba.conectar_presionado(bifurcacion2_arriba)
self.izquierda.conectar_presionado(bifurcacion2_izquierda)
if (self.casillero_actual == (133, -18)):
self.arriba = pilas.actores.Boton(x=10, y=175)
self.arriba.definir_imagen('data/img/interfaz/arriba.png')
self.arriba.escala = 0.5
self.izquierda = pilas.actores.Boton(x=10, y=120)
self.izquierda.definir_imagen('data/img/interfaz/izquierda.png')
self.izquierda.escala = 0.5
self.arriba.conectar_presionado(bifurcacion3_arriba)
self.izquierda.conectar_presionado(bifurcacion3_izquierda)
if (self.casillero_actual == (-185, -151)):
self.arriba = pilas.actores.Boton(x=10, y=175)
self.arriba.definir_imagen('data/img/interfaz/arriba.png')
self.arriba.escala = 0.5
self.abajo = pilas.actores.Boton(x=10, y=120)
self.abajo.definir_imagen('data/img/interfaz/abajo.png')
self.abajo.escala = 0.5
self.arriba.conectar_presionado(bifurcacion4_arriba)
self.abajo.conectar_presionado(bifurcacion4_abajo)
def verde(self):
pilas.almacenar_escena(Adivinanza(self.nombre, self.datos))
def naranja(self):
pilas.almacenar_escena(Trabalenguas(self.nombre, self.datos))
def violeta(self):
pilas.almacenar_escena(Chistes())
def ahorcado_juego(self):
pilas.almacenar_escena(Ahorcado(self.nombre, self.datos))
def preguntar_accion(self):
if (self.casillero_actual in casilleros_bifurcacion):
pilas.mundo.agregar_tarea(2.5, self.preguntar)
elif (self.imagenes_posiciones[casilleros.index(
self.casillero_actual)] == "data/img/iconos/pare.png"):
pilas.mundo.agregar_tarea(2.5, self.retroceder)
pilas.mundo.agregar_tarea(3, self.act)
elif (self.imagenes_posiciones[casilleros.index(
self.casillero_actual)] == "data/img/iconos/perder_vida.png"):
pilas.mundo.agregar_tarea(2.3, self.perder_vida)
pilas.mundo.agregar_tarea(2.5, self.act)
elif (self.imagenes_posiciones[casilleros.index(self.casillero_actual)]
== "data/img/iconos/teletransportacion.png"):
pilas.mundo.agregar_tarea(2.5, self.teletransportacion)
pilas.mundo.agregar_tarea(3, self.act)
elif (self.imagenes_posiciones[casilleros.index(
self.casillero_actual)] == "data/img/iconos/Casillero.png"):
pilas.mundo.agregar_tarea(2.5, self.act)
elif (self.imagenes_posiciones[casilleros.index(self.casillero_actual)]
== "data/img/iconos/CasilleroVerde.png"):
pilas.mundo.agregar_tarea(2.5, self.verde)
pilas.mundo.agregar_tarea(3, self.actualizar_energia)
pilas.mundo.agregar_tarea(3.2, self.act)
elif (self.imagenes_posiciones[casilleros.index(self.casillero_actual)]
== "data/img/iconos/CasilleroVioleta.png"):
pilas.mundo.agregar_tarea(2, self.desactivar_sonido)
pilas.mundo.agregar_tarea(2.5, self.violeta)
pilas.mundo.agregar_tarea(3.4, self.ver_est)
pilas.mundo.agregar_tarea(4, self.act)
elif (self.imagenes_posiciones[casilleros.index(self.casillero_actual)]
== "data/img/iconos/CasilleroNaranja.png"):
pilas.mundo.agregar_tarea(2.5, self.naranja)
pilas.mundo.agregar_tarea(3, self.actualizar_energia)
pilas.mundo.agregar_tarea(3.2, self.act)
elif (self.imagenes_posiciones[casilleros.index(
self.casillero_actual)] == "data/img/iconos/ahorcado.png"):
pilas.mundo.agregar_tarea(2.5, self.ahorcado_juego)
pilas.mundo.agregar_tarea(3, self.actualizar_energia)
pilas.mundo.agregar_tarea(3.2, self.act)
elif (self.imagenes_posiciones[casilleros.index(self.casillero_actual)]
== "data/img/iconos/Casillero_comodin.png"):
def eliminar_cartel():
self.boton_violeta.desactivar()
self.boton_violeta.destruir()
self.boton_naranja.desactivar()
self.boton_naranja.destruir()
self.boton_verde.desactivar()
self.boton_verde.destruir()
self.cartel_comodin.destruir()
def conectar_violeta():
pilas.mundo.agregar_tarea(1, self.desactivar_sonido)
pilas.mundo.agregar_tarea(1.5, self.violeta)
pilas.mundo.agregar_tarea(1.6, eliminar_cartel)
pilas.mundo.agregar_tarea(1.7, self.ver_est)
pilas.mundo.agregar_tarea(1.9, self.act)
def conectar_naranja():
pilas.mundo.agregar_tarea(1.5, self.naranja)
pilas.mundo.agregar_tarea(1.6, eliminar_cartel)
pilas.mundo.agregar_tarea(1.7, self.actualizar_energia)
pilas.mundo.agregar_tarea(1.9, self.act)
def conectar_verde():
pilas.mundo.agregar_tarea(1.5, self.verde)
pilas.mundo.agregar_tarea(1.6, eliminar_cartel)
pilas.mundo.agregar_tarea(1.7, self.actualizar_energia)
pilas.mundo.agregar_tarea(1.9, self.act)
def generar_botones():
#Boton violeta
self.boton_violeta = pilas.actores.Boton(x=10, y=87)
self.boton_violeta.definir_imagen(
'data/img/interfaz/boton_violeta.png')
self.boton_violeta.escala = 0.7
self.boton_violeta.conectar_presionado(conectar_violeta)
#Boton naranja
self.boton_naranja = pilas.actores.Boton(x=10, y=-65)
self.boton_naranja.definir_imagen(
'data/img/interfaz/boton_naranja.png')
self.boton_naranja.escala = 0.7
self.boton_naranja.conectar_presionado(conectar_naranja)
#Boton verde
self.boton_verde = pilas.actores.Boton(x=16, y=-225)
self.boton_verde.definir_imagen(
'data/img/interfaz/boton_verde.png')
self.boton_verde.escala = 0.7
self.boton_verde.conectar_presionado(conectar_verde)
self.des()
self.cartel_comodin = pilas.actores.Actor(
'data/img/iconos/cartel_comodin.png', y=-70)
self.cartel_comodin.escala = [2.5, 2], 0.8
pilas.mundo.agregar_tarea(1, generar_botones)
def mover(self, mov):
mover_x = []
mover_y = []
for x in mov:
mover_x.append(x[0])
mover_y.append(x[1])
self.personaje.x = pilas.interpolar(mover_x, 2)
self.personaje.y = pilas.interpolar(mover_y, 2)
def tirar_dado(self):
self.sonido_dado.reproducir()
n = self.dado.tirar()
mov = []
self.des()
for x in range(n):
#Movimiento en camino_1
if (self.casillero_actual
in camino_1) and (self.camino_actual.index(
self.casillero_actual) < len(camino_1) - 1):
i = self.camino_actual.index(self.casillero_actual) + 1
self.casillero_actual = self.camino_actual[i]
mov.append(self.casillero_actual)
elif (self.casillero_actual
in camino_1) and (self.camino_actual.index(
self.casillero_actual) == len(camino_1) - 1) and (x < n):
self.camino_actual = random.choice(sorteo_b2)
self.casillero_actual = self.camino_actual[0]
mov.append(self.casillero_actual)
elif (self.casillero_actual
in camino_1) and (self.camino_actual.index(
self.casillero_actual) == len(camino_1) - 1) and (x
== n):
self.casillero_actual = casilleros_bifurcacion[1]
mov.append(self.casillero_actual)
#Movimiento en camino_2
if (self.casillero_actual
in camino_2) and (self.camino_actual.index(
self.casillero_actual) < len(camino_2) - 1):
i = self.camino_actual.index(self.casillero_actual) + 1
self.casillero_actual = self.camino_actual[i]
mov.append(self.casillero_actual)
elif (self.casillero_actual
in camino_2) and (self.camino_actual.index(
self.casillero_actual) == len(camino_2) - 1) and (x < n):
self.camino_actual = random.choice(sorteo_b3)
self.casillero_actual = self.camino_actual[0]
mov.append(self.casillero_actual)
elif (self.casillero_actual
in camino_2) and (self.camino_actual.index(
self.casillero_actual) == len(camino_2) - 1) and (x
== n):
self.casillero_actual = casilleros_bifurcacion[2]
mov.append(self.casillero_actual)
#Movimiento en camino_3
if (self.casillero_actual
in camino_3) and (self.camino_actual.index(
self.casillero_actual) < len(camino_3) - 1):
i = self.camino_actual.index(self.casillero_actual) + 1
self.casillero_actual = self.camino_actual[i]
mov.append(self.casillero_actual)
elif (self.casillero_actual
in camino_3) and (self.camino_actual.index(
self.casillero_actual) == len(camino_3) - 1) and (x < n):
self.camino_actual = random.choice(sorteo_b3)
self.casillero_actual = self.camino_actual[0]
mov.append(self.casillero_actual)
elif (self.casillero_actual
in camino_3) and (self.camino_actual.index(
self.casillero_actual) == len(camino_3) - 1) and (x
== n):
self.casillero_actual = casilleros_bifurcacion[2]
mov.append(self.casillero_actual)
#Movimiento en camino_4
if (self.casillero_actual
in camino_4) and (self.camino_actual.index(
self.casillero_actual) < len(camino_4) - 1):
i = self.camino_actual.index(self.casillero_actual) + 1
self.casillero_actual = self.camino_actual[i]
mov.append(self.casillero_actual)
elif (self.casillero_actual
in camino_4) and (self.camino_actual.index(
self.casillero_actual) == len(camino_4) - 1) and (x < n):
self.camino_actual = random.choice(sorteo_b4)
self.casillero_actual = self.camino_actual[0]
mov.append(self.casillero_actual)
elif (self.casillero_actual
in camino_4) and (self.camino_actual.index(
self.casillero_actual) == len(camino_4) - 1) and (x
== n):
self.casillero_actual = casilleros_bifurcacion[3]
mov.append(self.casillero_actual)
#Movimiento en camino_5
if (self.casillero_actual
in camino_5) and (self.camino_actual.index(
self.casillero_actual) < len(camino_5) - 1):
i = self.camino_actual.index(self.casillero_actual) + 1
self.casillero_actual = self.camino_actual[i]
mov.append(self.casillero_actual)
elif (self.casillero_actual
in camino_5) and (self.camino_actual.index(
self.casillero_actual) == len(camino_5) - 1):
self.casillero_actual = casillero_castillo
mov.append(self.casillero_actual)
break
#Movimiento en camino_6
if (self.casillero_actual
in camino_6) and (self.camino_actual.index(
self.casillero_actual) < len(camino_6) - 1):
i = self.camino_actual.index(self.casillero_actual) + 1
self.casillero_actual = self.camino_actual[i]
mov.append(self.casillero_actual)
elif (self.casillero_actual
in camino_6) and (self.camino_actual.index(
self.casillero_actual) == len(camino_6) - 1):
self.casillero_actual = casillero_castillo
mov.append(self.casillero_actual)
break
#Movimiento en camino_7
if (self.casillero_actual
in camino_7) and (self.camino_actual.index(
self.casillero_actual) < len(camino_7) - 1):
i = self.camino_actual.index(self.casillero_actual) + 1
self.casillero_actual = self.camino_actual[i]
mov.append(self.casillero_actual)
elif (self.casillero_actual
in camino_7) and (self.camino_actual.index(
self.casillero_actual) == len(camino_7) - 1):
self.casillero_actual = casillero_castillo
mov.append(self.casillero_actual)
break
#Movimiento en camino_8
if (self.casillero_actual
in camino_8) and (self.camino_actual.index(
self.casillero_actual) < len(camino_8) - 1):
i = self.camino_actual.index(self.casillero_actual) + 1
self.casillero_actual = self.camino_actual[i]
mov.append(self.casillero_actual)
elif (self.casillero_actual
in camino_8) and (self.camino_actual.index(
self.casillero_actual) == len(camino_8) - 1):
self.casillero_actual = casillero_castillo
mov.append(self.casillero_actual)
break
#Movimiento inicial
if (self.casillero_actual == casillero_mapa) and (n > 1):
self.camino_actual = random.choice(sorteo_b1)
self.casillero_actual = self.camino_actual[0]
mov.append(self.casillero_actual)
elif (self.casillero_actual == casillero_mapa) and (n == 1):
self.casillero_actual = casilleros_bifurcacion[0]
mov.append(self.casillero_actual)
#Parche para que funcione adecuamente el camino 3 con la bifurcacion
if (self.casillero_actual in camino_3) and (self.camino_actual.index(
self.casillero_actual) > 1):
self.casillero_actual = (self.casillero_actual[0],
self.casillero_actual[1] - 1)
#Parche para que funcionen adecuadamente los caminos 5 y 6 con los juegos
if (self.casillero_actual in camino_5) and (self.camino_actual.index(
self.casillero_actual) > 1):
self.casillero_actual = (self.casillero_actual[0] - 1,
self.casillero_actual[1])
self.camino_actual = camino_8
if (self.casillero_actual in camino_6) and (self.camino_actual.index(
self.casillero_actual) > 9):
self.casillero_actual = (self.casillero_actual[0] + 1,
self.casillero_actual[1])
self.camino_actual = camino_8
#Parche para que funcione adecuadamente el casillero castillo
if (self.casillero_actual in camino_8) and (self.camino_actual.index(
self.casillero_actual) > 14):
self.casillero_actual = (self.casillero_actual[0],
self.casillero_actual[1] - 1)
#Movimiento
self.mover(mov)
#Final
if (self.casillero_actual == casillero_castillo):
pilas.mundo.agregar_tarea(2.5, self.gano)
else:
#Acciones a realizar al caer en un casillero determinado
self.preguntar_accion()
class Ahorcado(Base):
def __init__(self, nombre='',datos =''):
Base.__init__(self)
self.nombre = nombre
archivo = open("data/archivos/usuarios.json",'r')
dato = json.load(archivo)
archivo.close()
self.tema = dato[self.nombre]["tema_ahorcado"]
self.datos = datos
self.intentos = 6
def fondo(self):
pilas.fondos.Fondo("data/img/fondos/ahorcado.jpg")
def iniciar(self):
self.fondo()
self.crear_letras()
self.titulo = pilas.actores.Actor("data/img/enunciados/ahorcado.png", y= 250)
self.titulo.escala = 0.4
palo_ahorcado = pilas.actores.Actor('data/img/iconos/palo_ahorcado.png',x=280,y=100)
palo_ahorcado.escala = 2
self.generar_palabra()
def crear_letras(self):
self.lista_letras = []
for x in range(len(letras)):
self.actor_letra = Letra(letra=letras[x], x=cord_letras[x][0], y=cord_letras[x][1])
self.actor_letra.escala = 0.74
self.lista_letras.append(self.actor_letra)
self.actor_letra.activar()
self.actor_letra.conectar_presionado(self.presiona_tecla, arg=x)
def presiona_tecla(self, x):
self.actor_letra = self.lista_letras[x]
letra_mayus = self.actor_letra.getLetra()
self.letra = letra_mayus.lower()
self.intentar()
def generar_palabra(self):
#Timer
self.time = Temporizador(x=-250,y=300)
self.time.setDatas(0)
self.time.iniciar_aum()
self.guion = []
self.letras_utilizadas = []
self.letras_adivinadas = 0
if(self.tema == 'Animales'):
self.palabra = random.choice(animales)
if(self.tema == 'Frutas'):
self.palabra = random.choice(frutas)
if(self.tema == 'Meses'):
self.palabra = random.choice(meses)
if(self.tema == 'Instrumentos'):
self.palabra = random.choice(instrumentos)
if (len(self.palabra) <= 5):
self.posx = -270
for x in range(0,len(self.palabra)):
self.actor_guion = pilas.actores.Actor("data/img/interfaz/guion.png",x=self.posx,y=-280)
self.guion.append(self.posx)
self.posx = self.posx + 100
self.actor_guion.escala = 0.12
elif(len(self.palabra) <= 9):
self.posx = -400
for x in range(0,len(self.palabra)):
self.actor_guion = pilas.actores.Actor("data/img/interfaz/guion.png",x=self.posx,y=-280)
self.guion.append(self.posx)
self.posx = self.posx + 100
self.actor_guion.escala = 0.12
else:
self.posx = -450
for x in range(0,len(self.palabra)):
self.actor_guion = pilas.actores.Actor("data/img/interfaz/guion.png",x=self.posx,y=-280)
self.guion.append(self.posx)
self.posx = self.posx + 80
self.actor_guion.escala = 0.09
def gano(self):
for y in range(0,len(self.lista_letras)):
self.actor_letra = self.lista_letras[y]
self.actor_letra.desactivar()
self.profesor = pilas.actores.Actor("data/img/iconos/profesor.png",x=500,y=-180)
self.profesor.escala = 0.095
self.profesor.x = [440]
self.profesor.decir('Bien echo, ganaste 1 punto mas de energia!')
self.ener = True
pilas.mundo.agregar_tarea(1,self.profesor.eliminar)
pilas.avisar('Volviendo al tablero..')
pilas.mundo.agregar_tarea(2,self.volver)
def perdio(self):
self.profesor = pilas.actores.Actor("data/img/iconos/profesor.png",x=500,y=-180)
self.profesor.escala = 0.095
self.profesor.x = [440]
self.profesor.decir('Lo siento, perdiste 1 punto de energia!')
self.ener = False
pilas.mundo.agregar_tarea(1,self.profesor.eliminar)
pilas.avisar('Volviendo al tablero..')
pilas.mundo.agregar_tarea(2,self.volver)
def cuerpo(self):
if(self.intentos == 5):
cabeza = pilas.actores.Actor('data/img/iconos/cabeza.png',x=263,y=190)
if(self.intentos == 4):
torzo = pilas.actores.Pizarra()
torzo.linea(263,152,263,20,pilas.colores.negro,grosor=6)
if(self.intentos == 3):
brazo_derecho = pilas.actores.Pizarra()
brazo_derecho.linea(263,130,210,95,pilas.colores.negro,grosor=6)
if(self.intentos == 2):
brazo_izquierdo = pilas.actores.Pizarra()
brazo_izquierdo.linea(263,130,316,95,pilas.colores.negro,grosor=6)
if(self.intentos == 1):
pierna_derecha = pilas.actores.Pizarra()
pierna_derecha.linea(263,20,218,-34,pilas.colores.negro,grosor=6)
if(self.intentos == 0):
pierna_izquierda = pilas.actores.Pizarra()
pierna_izquierda.linea(263,20,308,-34,pilas.colores.negro,grosor=6)
self.perdio()
def intentar(self):
no_se_encuentra = True
indice = 0
if(self.intentos == 0):
self.perdio()
else:
if(self.letra in self.letras_utilizadas):
self.profesor = pilas.actores.Actor("data/img/iconos/profesor.png",x=500,y=-180)
self.profesor.escala = 0.095
self.profesor.x = [440]
self.profesor.decir('Ya utilizaste esa letra!')
pilas.mundo.agregar_tarea(2,self.profesor.eliminar)
else:
for x in self.palabra:
if(self.letra == x):
no_se_encuentra = False
break
if(no_se_encuentra == True):
self.profesor = pilas.actores.Actor("data/img/iconos/profesor.png",x=500,y=-180)
self.profesor.escala = 0.095
self.profesor.x = [440]
self.profesor.decir('Ups, esa letra no se encuentra en la palabra!')
pilas.mundo.agregar_tarea(2,self.profesor.eliminar)
self.letras_utilizadas.append(self.letra)
self.intentos = self.intentos-1
self.cuerpo()
else:
for x in self.palabra:
if (self.letra==x) and (self.letras_adivinadas<len(self.palabra)):
self.letra_adivinada = pilas.actores.Texto(x,fuente="data/fonts/American Captain.ttf",y=-258)
self.letra_adivinada.escala = 2
self.letra_adivinada.color = pilas.colores.negro
self.letra_adivinada.x = self.guion[indice]
self.letras_adivinadas = self.letras_adivinadas + 1
self.letras_utilizadas.append(x)
if (self.letras_adivinadas == len(self.palabra)):
self.gano()
indice = indice + 1
def volver(self):
self.time.stopTimer()
self.datos[self.nombre]['tiempo_ahorcado'][0] = self.datos[self.nombre]['tiempo_ahorcado'][0] + self.time.getTime()
self.datos[self.nombre]['tiempo_ahorcado'][1] = self.datos[self.nombre]['tiempo_ahorcado'][1] + 1
if(self.ener == False):
self.datos[self.nombre]['tiempo_ahorcado'][2] = self.datos[self.nombre]['tiempo_ahorcado'][2] + 1
f = open("data/archivos/estadisticas.json","w")
f.write(json.dumps(self.datos))
f.close()
e = open("data/archivos/energia.txt",'wb')
pickle.dump(self.ener,e)
e.close()
pilas.recuperar_escena()
def _lanzar_temporizador(self):
estado_actual = self._proceso.get_estado()
self._temporizador = Temporizador(estado_actual.get_nombre())
self._temporizador.set_duracion(estado_actual.get_duracion())
self._temporizador.iniciar_cuenta_regresiva()
from unidadtiempo import UnidadTiempo
from temporizador import Temporizador
t=Temporizador(UnidadTiempo(23),UnidadTiempo(59),UnidadTiempo(59))
t.iniciar([0,10,5])
for i in range(605):
t.retroceder()
print str(t.h.valor) + ":" + str (t.m.valor)+ ":" + str(t.s.valor)
for i in range(605):
t.avanzar()
print str(t.h.valor) + ":" + str (t.m.valor)+ ":" + str(t.s.valor)
class Trabalenguas(Base):
def __init__(self, nombre, datos):
Base.__init__(self)
self.nombre = nombre
self.datos = datos
def iniciar(self):
self.fondo()
self.explicacion()
def fondo(self):
pilas.fondos.Fondo('data/img/fondos/trabalenguas.jpg')
def explicacion(self):
self.titulo = pilas.actores.Actor(
"data/img/enunciados/trabalenguas.png", y=200)
self.titulo.escala = 0.5
self.explicacion_texto = pilas.actores.Actor(
"data/img/interfaz/enunciado_trabalenguas.png")
self.explicacion_texto.escala = 0.8
pilas.mundo.agregar_tarea(7, self.mostrar)
def mostrar(self):
self.explicacion_texto.eliminar()
self.indice = random.randrange(0, 12)
self.recuadro = pilas.actores.Actor("data/img/interfaz/recuadrito.png",
x=-20,
y=-20)
self.recuadro.escala = 0.45
self.texto = pilas.actores.Texto(
trabalenguas[self.indice],
fuente="data/fonts/American Captain.ttf",
ancho=256)
self.texto.color = pilas.colores.negro
pilas.mundo.agregar_tarea(10, self.seguir)
def seguir(self):
self.time = Temporizador(x=-300, y=300)
self.time.setDatas(0)
self.time.iniciar_aum()
self.texto.eliminar()
self.texto_nuevo = pilas.actores.Texto(
problemas[self.indice],
fuente="data/fonts/American Captain.ttf",
ancho=256)
self.texto_nuevo.color = pilas.colores.negro
self.personaje = pilas.actores.Actor("data/img/iconos/character.png",
x=700)
self.personaje.escala = 0.3
self.personaje.x = [400]
self.personaje.y = [-200]
self.mostrar_incorrecto()
def verificar(self, respuesta):
respuestas = {
"%s / %s" % (trabalenguas_solucion[self.indice][0], trabalenguas_solucion[self.indice][1]):
"correcto",
"%s / %s" % (trabalenguas_solucion[self.indice][0], trabalenguas_solucion[self.indice][2]):
"incorrecto",
"%s / %s" % (trabalenguas_solucion[self.indice][1], trabalenguas_solucion[self.indice][2]):
"incorrecto"
}
if (respuestas[respuesta] == "correcto"):
self.personaje.decir("Bien hecho , era la respuesta correcta")
self.ener = True
else:
self.personaje.decir(
"Respuesta incorrecta , mejor suerte la proxima")
self.ener = False
pilas.mundo.agregar_tarea(2, self.volver)
def mostrar_incorrecto(self):
dialogo = pilas.actores.Dialogo()
respuesta_correcta = "%s / %s" % (trabalenguas_solucion[
self.indice][0], trabalenguas_solucion[self.indice][1])
respuesta_incorrecta1 = "%s / %s" % (trabalenguas_solucion[
self.indice][0], trabalenguas_solucion[self.indice][2])
respuesta_incorrecta2 = "%s / %s" % (trabalenguas_solucion[
self.indice][1], trabalenguas_solucion[self.indice][2])
self.opciones = [
respuesta_correcta, respuesta_incorrecta1, respuesta_incorrecta2
]
random.shuffle(self.opciones)
dialogo.elegir(self.personaje, "Que palabras faltan?", self.opciones,
self.verificar)
pilas.mundo.agregar_tarea(2, dialogo.iniciar)
def volver(self):
self.time.stopTimer()
self.datos[self.nombre]['tiempo_trabalenguas'][0] = self.datos[
self.nombre]['tiempo_trabalenguas'][0] + self.time.getTime()
self.datos[self.nombre]['tiempo_trabalenguas'][1] = self.datos[
self.nombre]['tiempo_trabalenguas'][1] + 1
if (self.ener == False):
self.datos[self.nombre]['tiempo_trabalenguas'][2] = self.datos[
self.nombre]['tiempo_trabalenguas'][2] + 1
f = open("data/archivos/estadisticas.json", "w")
f.write(json.dumps(self.datos))
f.close()
e = open("data/archivos/energia.txt", 'wb')
pickle.dump(self.ener, e)
e.close()
pilas.recuperar_escena()