def setUp(self):
self.interfaz4 = Interfaz(4)
self.interfaz4.tablero=\
[["4", "x", "3", "1"],
["x", "3", "x", "x"],
["3", "1", "x", "2"],
["x", "4", "x", "x"]]
self.interfaz4.logica = Sudoku(self.interfaz4.tablero, 4)
def mostrar_canje(self,tarjetas,jugador):
"""Muestra por pantalla la tarjetas canejada"""
paises = []
for tipo in tarjetas:
for tarjeta in tarjetas[tipo]:
paises.append(tarjeta.su_pais())
Interfaz.setear_titulo( jugador.su_nombre()+" realizo canje de tarjetas: "+paises[0]+" "+paises[1]+" "+paises[2])
time.sleep(5)
self.tablero.actualizar_interfaz()
def __init__(self): """Constructor de la clase. Inicializa la interfaz grafica y los objetos que va a utilizar durante el juego.""" self.mazo = Mazo(paises.paises_por_tarjeta) self.dados = Dados() self.tablero = Tablero(paises.paises_por_continente, paises.paises_limitrofes) Interfaz.iniciar(paises.coordenadas_de_paises, paises.archivo_tablero, paises.color_tablero) self.jugadores = []
def actualizar_interfaz(self, agregados=None):
"""Redibuja interfaz grafica. Puede recibir un diccionario de
paises y numero de ejercitos que se adicionan o sustraen a los
que estan ubicados en el tablero.
Por ejemplo, si el diccionario fuera
{'Argentina': -1, 'Brasil': 1}, el tablero se dibujaria con un
ejercito menos en Argentina y uno mas en Brasil."""
Interfaz.ubicar_ejercitos(agregados)
def __init__(self):
self.__app = QApplication(sys.argv)
self.__mi_vista = Interfaz(
) # se accede a los atributos de la clase Interfaz
self.__mi_biosenal = Biosenal(
) # se accede a los atributos de la clase Biosenal
self.__mi_controlador = Coordinador(
self.__mi_vista, self.__mi_biosenal
) # Se le asigna al coordinador la vista y biosenal
self.__mi_vista.asignar_Controlador(
self.__mi_controlador) # Se le asigna al controlador la vista
def pedir_pais_propio(self, tablero, mensaje): """Recibe una cadena de texto y lo escribe en el titulo. Pide al jugador que seleccione un pais que sea suyo. Si clickea un pais suyo con click izquierdo, devuelve el pais. Si hace click derecho, devuelve None.""" Interfaz.setear_titulo(mensaje) origen, boton = Interfaz.seleccionar_pais() while boton == Interfaz.BOTON_IZQUIERDO and tablero.color_pais(origen) != self.color: origen, boton = Interfaz.seleccionar_pais() if boton != Interfaz.BOTON_IZQUIERDO: return None return origen
def configurar_el_juego(self):
"""Pone a los jugadores en el juego."""
Interfaz.setear_titulo('Configurando el juego')
n = Interfaz.elegir('Jugadores', 'Seleccione el numero de jugadores', range(2,7))
nombre_colores = NOMBRE_COLORES.values()
for i in range(n):
nombre = Interfaz.elegir('Jugador %d' % (i + 1), 'Ingrese el nombre del jugador %d' % (i + 1))
color = Interfaz.elegir('Jugador %d' % (i + 1), 'Ingrese el color del jugador %d' % (i + 1), nombre_colores)
nombre_colores.remove(color)
c = NOMBRE_COLORES.keys()[NOMBRE_COLORES.values().index(color)]
self.jugadores.append(Jugador(c, nombre))
def actualizar_interfaz(self, agregados = None):
"""Redibuja interfaz grafica. Puede recibir un diccionario de
paises y numero de ejercitos que se adicionan o sustraen a los
que estan ubicados en el tablero.
Por ejemplo, si el diccionario fuera
{'Argentina': -1, 'Brasil': 1}, el tablero se dibujaria con un
ejercito menos en Argentina y uno mas en Brasil."""
paises = {}
if agregados:
for pais in agregados:
paises[pais] = (self.paises[pais].su_color(), self.paises[pais].sus_ejercitos() + agregados[pais])
else:
for pais in self.paises:
paises[pais] = (self.paises[pais].su_color(), self.paises[pais].sus_ejercitos())
Interfaz.ubicar_ejercitos(paises)
def repartir_paises(self):
"""Reparte en ronda las tarjetas de paises y pone un ejercito
en cada uno de los paises."""
Interfaz.setear_titulo('Repartiendo paises iniciales')
ntarjetas = self.mazo.cantidad_tarjetas()
njugadores = len(self.jugadores)
for jugador in \
self.jugadores * (ntarjetas / njugadores) + \
random.sample(self.jugadores, ntarjetas % njugadores):
t = self.mazo.sacar_tarjeta()
self.tablero.ocupar_pais(t.pais, jugador.color, 1)
self.mazo.devolver_tarjeta(t)
class Principal(object):
def __init__(self):
self.__app = QApplication(sys.argv)
self.__mi_vista = Interfaz(
) # se accede a los atributos de la clase Interfaz
self.__mi_biosenal = Biosenal(
) # se accede a los atributos de la clase Biosenal
self.__mi_controlador = Coordinador(
self.__mi_vista, self.__mi_biosenal
) # Se le asigna al coordinador la vista y biosenal
self.__mi_vista.asignar_Controlador(
self.__mi_controlador) # Se le asigna al controlador la vista
def main(self):
self.__mi_vista.show() # Permite mostrar las ventanas
sys.exit(self.__app.exec_()) #Permite ejecutar la aplicación
def aceptarc(self,a):
self.tamano=int(self.texto.GetValue())
if self.tamano <9 and self.tamano >0:
app = wx.App()
Interfaz(None, title='Tabla del Algoritmo de Kruskal',n=self.tamano)
app.MainLoop()
else:
dlg = wx.MessageDialog(self, "Debe de ser menor a 9", "error de <ingreso></ingreso>", wx.OK | wx.ICON_INFORMATION)
dlg.ShowModal()
dlg.Destroy()
def reagrupar(self, tablero):
"""Recibe el tablero y le pide al jugador que seleccione todos
los ejercitos que desea reagrupar. Devuelve una lista de
reagrupamientos.
Solo se podran reagrupar ejercitos a paises limitrofes, nunca
un pais podra quedar vacio.
Un ejemplo de devolcion de esta funcion puede ser:
[('Argentina', 'Uruguay', 2), ('Argentina', 'Brasil', 1),
('Chile', 'Argentina', 1)]
Esto significa que de Argentina se reagrupan 3 ejercitos, 2 con
destino a Uruguay y 1 con destino a Brasil. Argentina tiene que
tener al menos 4 ejercitos. De Chile se pasa uno a Argentina,
por lo que Chile tiene que tener al menos 1. Todos los paises
tienen que pertenecer al jugador. Despues de implementado el
reagrupamiento, Brasil quedara con 1 ejercito mas, Uruguay con
2 mas, Argentina con 2 menos (salen 3, entra 1) y Chile con 1
menos."""
paises = tablero.paises_color(self.color)
opciones_paises = []
opciones_paises_destino = []
lista_reagrupamientos = []
for pais in paises:
if (tablero.paises[pais][1] > 1):
opciones_paises.append(pais)
pais_origen = Interfaz.elegir('Reagrupar Ejercitos','Seleccione el pais de origen',opciones_paises)
opciones_paises.remove(pais_origen)
cantidad_ejercitos = tablero.paises[pais_origen][1]
for pais in paises_limitrofes[pais_origen]:
if tablero.color_pais(pais) ==self.color:
opciones_paises_destino.append(pais)
while cantidad_ejercitos > 1:
pais_destino = Interfaz.elegir('Reagrupar Ejercitos','Seleccione el pais de Destino',opciones_paises_destino)
cantidad_ejercitos_mover = Interfaz.elegir('Reagrupar Ejercitos','Seleccione la cantidad',range(1,cantidad_ejercitos))
cantidad_ejercitos -= int(cantidad_ejercitos_mover)
lista_reagrupamientos.append((pais_origen,pais_destino,cantidad_ejercitos_mover))
return lista_reagrupamientos
class Test_Interfaz(unittest.TestCase):
def setUp(self):
self.interfaz = Interfaz()
def test_num_valid(self):
value = self.interfaz.validate(4)
self.assertTrue(value)
def test_num_NO_valid(self):
value = self.interfaz.validate('a')
self.assertFalse(value)
def test_row_valid(self):
value = self.interfaz.validate_x(1)
self.assertTrue(value)
def test_row_NO_valid(self):
value = self.interfaz.validate_x(11)
self.assertFalse(value)
def test_column_valid(self):
value = self.interfaz.validate_y(2)
self.assertTrue(value)
def test_column_NO_valid(self):
value = self.interfaz.validate_y(9)
self.assertFalse(value)
def agregar_ejercitos_inicial(self, inicia_ronda):
"""Realiza la primer fase de colocacion de ejercitos."""
Interfaz.setear_titulo('Incorporando ejercitos')
ejercitos_primera = int(math.ceil(self.tablero.cantidad_paises() / 10.0))
ejercitos_segunda = int(math.ceil(self.tablero.cantidad_paises() / 20.0))
for cantidad in (ejercitos_primera, ejercitos_segunda):
for i in range(len(self.jugadores)):
jugador = self.jugadores[(inicia_ronda + i) % len(self.jugadores)]
Interfaz.alertar(jugador, '%s pone ejercitos' % jugador.nombre)
# cantidad de ejercitos
#en cualquier continente
ejercitos = jugador.agregar_ejercitos(self.tablero, {"": cantidad})
#print(sum(ejercitos.values()))
#print(cantidad)
assert (sum(ejercitos.values()) == cantidad)
for pais in ejercitos:
assert (self.tablero.color_pais(pais) == jugador.color)
self.tablero.asignar_ejercitos(pais, ejercitos[pais])
self.tablero.actualizar_interfaz(self.tablero.paises)
def reagrupar(self, tablero):
"""Recibe el tablero y le pide al jugador que seleccione todos
los ejercitos que desea reagrupar. Devuelve una lista de
reagrupamientos.
Solo se podran reagrupar ejercitos a paises limitrofes, nunca
un pais podra quedar vacio.
Un ejemplo de devolucion de esta funcion puede ser:
[('Argentina', 'Uruguay', 2), ('Argentina', 'Brasil', 1),
('Chile', 'Argentina', 1)]
Esto significa que de Argentina se reagrupan 3 ejercitos, 2 con
destino a Uruguay y 1 con destino a Brasil. Argentina tiene que
tener al menos 4 ejercitos. De Chile se pasa uno a Argentina,
por lo que Chile tiene que tener al menos 1. Todos los paises
tienen que pertenecer al jugador. Despues de implementado el
reagrupamiento, Brasil quedara con 1 ejercito mas, Uruguay con
2 mas, Argentina con 2 menos (salen 3, entra 1) y Chile con 1
menos."""
reagrupamientos = []
restricciones = {}
pais_origen = True
while pais_origen:
pais_origen = self.pedir_pais_propio(tablero, "%s esta reagrupando. Seleccionar pais de origen." % self)
while pais_origen and not tablero.ejercitos_pais(pais_origen) > 1:
pais_origen = self.pedir_pais_propio(tablero, "%s esta reagrupando. Seleccionar pais de origen." % self)
if pais_origen:
ejercitos_posibles = tablero.ejercitos_pais(pais_origen)
if restricciones.has_key(pais_origen): # Si esta en restricciones es porque se hizo un reagrupamiento previo, al pais elegido.
ejercitos_posibles -= restricciones[pais_origen]
if ejercitos_posibles == 1: continue # Si es 1 ya no puede mover mas ejercitos desde ese pais.
cantidad_a_mover = Interfaz.elegir(self, 'Cuantos ejercitos se desplazan de %s?' % pais_origen, range(1, ejercitos_posibles))
pais_destino = self.pedir_pais_propio(tablero, '%s esta reagrupando. Seleccionar pais de destino.' % self)
while pais_destino and not tablero.es_limitrofe(pais_origen, pais_destino):
pais_destino = self.pedir_pais_propio(tablero, '%s esta reagrupando. Seleccionar pais de destino.' % self)
if not pais_destino: continue
cantidad_a_poner = cantidad_a_mover
cantidad_a_sacar = cantidad_a_mover
if restricciones.has_key(pais_origen):
cantidad_a_sacar += restricciones[pais_origen]
if restricciones.has_key(pais_destino):
cantidad_a_poner += restricciones[pais_destino]
restricciones[pais_origen] = restricciones.get(pais_origen, 0) + cantidad_a_mover
reagrupamientos.append((pais_origen, pais_destino, cantidad_a_mover))
tablero.actualizar_interfaz({pais_origen: - cantidad_a_sacar, pais_destino: cantidad_a_poner})
return reagrupamientos
def realizar_fase_reagrupamiento(self, jugador):
"""
Realiza el reagrupamiento de ejercitos.
"""
Interfaz.setear_titulo('%s reagrupa' % jugador)
Interfaz.alertar(jugador, '%s reagrupa' % jugador)
lista = jugador.reagrupar(self.tablero)
# Se fija que el reagrupamiento sea consistente:
salientes = {}
for origen, destino, cantidad in lista:
assert(self.tablero.es_limitrofe(origen, destino))
assert(self.tablero.color_pais(origen) == jugador.color)
assert(self.tablero.color_pais(destino) == jugador.color)
salientes[origen] = salientes.get(origen, 0) + cantidad
for pais in salientes:
assert(self.tablero.ejercitos_pais(pais) > salientes[pais])
# Aplica la lista de cambios:
for origen, destino, cantidad in lista:
self.tablero.asignar_ejercitos(origen, -cantidad)
self.tablero.asignar_ejercitos(destino, cantidad)
class Test_Interfaz(unittest.TestCase):
def setUp(self):
self.interfaz4 = Interfaz(4)
self.interfaz4.tablero=\
[["4", "x", "3", "1"],
["x", "3", "x", "x"],
["3", "1", "x", "2"],
["x", "4", "x", "x"]]
self.interfaz4.logica = Sudoku(self.interfaz4.tablero, 4)
def test_generar_tablero(self):
self.assertEqual(self.interfaz4.generar_tablero(),
self.interfaz4.tablero)
def test_obtener_valores(self):
user_input = [
'1',
'2',
'2',
]
with patch('builtins.input', side_effect=user_input):
resultado = self.interfaz4.obtener_valores()
self.assertEqual(resultado, ((0, 1), 2))
def __init__(self):
# Como heredamos de QObject hay que hacer el llamado a super()
super().__init__()
print("Inicializando cliente...")
# Inicializamos el socket principal del cliente.
# Este corresponde al de una conexión TCP
self.socket_cliente = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# Primero definimos la dirección a la cual nos conectaremos.
# En este caso se trabaja de manera local
self.host = "localhost"
# Definimos un Puerto al cual será conectado el cliente
self.port = 1238
try:
# Primero nos conectamos al servidor, pasándole como argumento la tupla
# (HOST, PORT) al cual nos queremos conectar.
# Esto tira error si la conexión es privada o si no hay un servidor "escuchando"
self.socket_cliente.connect((self.host, self.port))
print("Cliente conectado exitosamente al servidor...")
# hacemos True un boolean para que escuche
self.connected = True
# Luego, creamos un thread para comenzar a escuchar lo que nos envía el servidor
# Usamos un thread para permitir que el programa realice otras cosas
# mientras escucha al servidor
thread = threading.Thread(target=self.listen_thread, daemon=True)
thread.start()
print("Escuchando al servidor...")
# Finalmente, conectamos la señal con un método de la ventana
self.interfaz = Interfaz()
self.interfaz.senal_a_backend.connect(self.enviar_al_servidor)
self.enviar_a_interfaz.connect(self.interfaz.desplegar_resultado)
except ConnectionRefusedError:
# Si la conexión es rechazada, entonces se 'cierra' el socket
print("No se encontró un servidor\nAbortando...")
self.socket_cliente.close()
exit()
def atacar(self, tablero):
"""Le pide al usuario que ingrese un par de paises para
realizar un ataque. Devuelve None si el jugador no quiere
atacar y un par (atacante, atacado) en caso contrario."""
while True:
Interfaz.setear_titulo('%s ataca. Seleccionar atacante' % self)
atacante, boton = Interfaz.seleccionar_pais()
while boton == Interfaz.BOTON_IZQUIERDO and (tablero.color_pais(atacante) != self.color or tablero.ejercitos_pais(atacante) == 1):
atacante, boton = Interfaz.seleccionar_pais()
if boton != Interfaz.BOTON_IZQUIERDO:
return None
Interfaz.setear_titulo('%s ataca. Seleccionar pais atacado por %s' % (self, atacante))
atacado, boton = Interfaz.seleccionar_pais()
while boton == Interfaz.BOTON_IZQUIERDO and (tablero.color_pais(atacado) == self.color or not tablero.es_limitrofe(atacante, atacado)):
atacado, boton = Interfaz.seleccionar_pais()
if boton != Interfaz.BOTON_IZQUIERDO:
continue
return (atacante, atacado)
def __init__(self,parent=None):
global paradas
global distancias
global estimaciones
global inicio
global meta
global algoritmo
global conexiones
global opciones
#Cargamos los datos
paradas, distancias,estimaciones,conexiones = cargaDatos("datos")
algoritmo = 0
opciones = 0
inicio = paradas[0]
meta = paradas[0]
#Creamos la interfaz
QtGui.QWidget.__init__(self,parent)
self.ui=Interfaz()
self.ui.setupUi(self)
def realizar_fase_ataque(self, jugador):
"""Implementa la fase de ataque de un jugador.
Sucesivamente hace combatir a los paises seleccionados.
Devuelve el numero de paises conquistados."""
Interfaz.setear_titulo('%s ataca' % jugador)
Interfaz.alertar(jugador, '%s ataca' % jugador)
paises_ganados = 0
while True:
ataque = jugador.atacar(self.tablero)
if not ataque:
break
atacante, atacado = ataque
assert (self.tablero.es_limitrofe(atacante, atacado))
assert (self.tablero.ejercitos_pais(atacante) > 1)
self.dados.lanzar_dados(self.tablero.ejercitos_pais(atacante), self.tablero.ejercitos_pais(atacado))
self.tablero.asignar_ejercitos(atacante, -self.dados.ejercitos_perdidos_atacante())
self.tablero.asignar_ejercitos(atacado, -self.dados.ejercitos_perdidos_atacado())
Interfaz.setear_titulo('%s: -%d, %s: -%d %s' % (
atacante, self.dados.ejercitos_perdidos_atacante(), atacado, self.dados.ejercitos_perdidos_atacado(),
self.dados))
if self.tablero.ejercitos_pais(atacado) == 0:
paises_ganados += 1
mover = Interfaz.elegir(jugador, 'Cuantos ejercitos se desplazan a %s?' % atacado,
range(1, min(self.tablero.ejercitos_pais(atacante) - 1, 3) + 1))
self.tablero.asignar_ejercitos(atacante, -mover)
self.tablero.ocupar_pais(atacado, jugador.color, mover)
self.tablero.actualizar_interfaz(self.tablero.paises)
else:
self.tablero.actualizar_interfaz(self.tablero.paises)
time.sleep(5)
return paises_ganados
from interfaz import Interfaz
class Sample:
def __init__(self):
self.lista = [[0 for y in range(32)] for x in range(36)]
def func_alumno1(self, num):
valor = 32 - num if num < 32 else 2
self.lista = [[0 for y in range(valor)] for x in range(valor)]
return self.lista
def func_alumno2(self, tupla):
return self.lista
def consulta1(self, tupla):
return ["Respuesta1", "Respuesta2", tupla]
def consulta5(self, tupla):
return 1
if __name__ == '__main__':
sample = Sample()
funciones = [sample.consulta1, sample.consulta1,
sample.consulta1, sample.consulta5, sample.consulta5]
interfaz = Interfaz(
sample.func_alumno1, sample.func_alumno2, sample.lista, funciones)
interfaz.run()
class Sample:
def __init__(self):
self.lista = [[0 for y in range(32)] for x in range(36)]
def func_alumno1(self, num):
valor = 32 - num if num < 32 else 2
self.lista = [[0 for y in range(valor)] for x in range(valor)]
return self.lista
def func_alumno2(self, tupla):
return self.lista
def consulta1(self, tupla):
return ["Respuesta1", "Respuesta2", tupla]
def consulta5(self, tupla):
return 1
if __name__ == '__main__':
sample = Sample()
funciones = [sample.consulta1, sample.consulta1,
sample.consulta1, sample.consulta5, sample.consulta5]
interfaz = Interfaz(
sample.func_alumno1, sample.func_alumno2, sample.lista, funciones)
interfaz.run()
FunctionItem("Editar hora evento de limpieza",
interfaz.editar_hora_evento_limpieza))
submenu_limpieza.append_item(
FunctionItem("Marcar evento de limpieza realizado",
interfaz.set_evento_limpieza_completado))
submenu_limpieza.append_item(
FunctionItem("Sumar ordenanza a un evento de limpieza",
interfaz.sumar_ordenanza_a_equipo_limpieza))
submenu_limpieza.append_item(
FunctionItem("Quitar ordenanza de un evento de limpieza",
interfaz.restar_ordenanza_a_equipo_limpieza))
# Menu principal
menu_principal = ConsoleMenu("Intendencia", exit_option_text="Salir")
menu_principal.append_item(SubmenuItem("Agentes", submenu=submenu_agentes))
menu_principal.append_item(SubmenuItem("Lugar", submenu=submenu_lugares))
menu_principal.append_item(
SubmenuItem("Incidentes", submenu=submenu_incidentes))
menu_principal.append_item(
SubmenuItem("Limpieza", submenu=submenu_limpieza))
# Activa el menu
menu_principal.show()
logging.debug('Show menu')
if __name__ == "__main__":
start_log()
interfaz = Interfaz()
menu()
def test_Interfaz_5_fila_y_valor_no_valido(self):
usuario = Interfaz()
usuario.tamaño = 9
self.assertFalse(usuario.ingresar_valor("d", 4, "a"))
class Principal(QtGui.QMainWindow):
#Creamos un Widget
#Le asignamos el correspondiente Ui
#Lo colocamos
#definimos los slots
def __init__(self,parent=None):
global paradas
global distancias
global estimaciones
global inicio
global meta
global algoritmo
global conexiones
global opciones
#Cargamos los datos
paradas, distancias,estimaciones,conexiones = cargaDatos("datos")
algoritmo = 0
opciones = 0
inicio = paradas[0]
meta = paradas[0]
#Creamos la interfaz
QtGui.QWidget.__init__(self,parent)
self.ui=Interfaz()
self.ui.setupUi(self)
#Boton reiniciar
def reiniciar(self):
self.ui.listaRuta.clear()
self.ui.reiniciarMapa()
#Boton cerrar
def cerrar(self):
sys.exit()
#Boton empezar
def empezar(self):
self.reiniciar()
global algoritmo
print algoritmo
global opciones
if algoritmo is 1:
ruta = greedy(paradas,distancias,estimaciones,inicio,meta)
else:
ruta = algoritmoA(paradas,distancias,estimaciones,conexiones,inicio,meta,opciones)
print "El resultado es"
for nodo in ruta:
print nodo
self.ui.actualizarLista(ruta)
#Algoritmo para resaltar resultado
#Lista de cambio de estacion de inicio
def cambiarInicio(self,pos):
global inicio
inicio = paradas[pos]
#Lista de cambio de estacion de meta
def cambiarFin(self,pos):
global meta
meta = paradas[pos]
#Lista de cambio de algoritmo
def cambiarAlgoritmo(self,pos):
global algoritmo
algoritmo = pos
#Lista de cambio de algoritmo
def cambiarOpcion(self,pos):
global opciones
opciones = pos
print opciones
def test_nothing_valid(self):
user = Interfaz()
result = user.enter(".", "%", "d")
self.assertFalse(result)
def test_interfaz_10(self):
usuario = Interfaz()
usuario.tamaño = 9
self.assertTrue(usuario.ingresar_valor(2, 5, 9))
def test_interfaz_11(self):
usuario = Interfaz()
usuario.tamaño = 9
self.assertTrue(usuario.ingresar_valor(6, 8, 2))
def sumar_ejercito(self,opciones_paises):
pais = Interfaz.elegir('Agregar Ejercito','Seleccione el pais, para agregar tropas',opciones_paises)
if self.ejercitos_paises.has_key(pais):
self.ejercitos_paises[pais]+=1
else:
self.ejercitos_paises[pais]=1
def test_Interfaz_1(self):
usuario = Interfaz()
usuario.tamaño = 9
self.assertTrue(usuario.ingresar_valor(2, 1, 8))
import os, logging
from readEmail import readEmails, deleteMails, filterMails
from commands import getCommandWords, addCommand, getFiles, runCommands
from interfaz import Interfaz
# Running menssage
print ("Reading emails...")
# Files and initial vars
currentDir = os.path.dirname(__file__)
pathCredentails = os.path.join(currentDir, 'credentials.json')
pathConfig = os.path.join(currentDir, 'config.json')
logPath = os.path.join(currentDir, 'logs.txt')
# Run interfaz
myInterfaz = Interfaz (pathCredentails, pathConfig)
# Get credentials
credentials = myInterfaz.getCredentials()
myEmail = credentials['myEmail']
password = credentials['pass']
fromEmail = credentials['fromEmail']
imap = credentials['imap']
folder = credentials['folder']
search = credentials['search']
secretWord = credentials['secretWord']
# Acess and return all menssage
allEmails = readEmails (imap, myEmail, password, folder, search)
# Get command words
from interfaz import Interfaz
from parsing import obtener_datos
import time
now = time.time()
### Si los archivos no estan en la carpeta data, por favor especificar el path
dic_personas = obtener_datos('data/personas.txt')
dic_cursos = obtener_datos('data/cursos.txt')
dic_evaluaciones = obtener_datos('data/evaluaciones.txt')
dic_requisitos = obtener_datos('data/requisitos.txt')
bummer = Interfaz()
bummer.instanciar_personas(dic_personas)
bummer.instanciar_cursos(dic_cursos, dic_requisitos, dic_evaluaciones)
print('Tiempo en cargar: {} seg'.format(str(time.time() - now)))
bummer.set_time()
bummer.correr()
def test_Interfaz_2(self):
usuario = Interfaz()
usuario.tamaño = 9
self.assertTrue(usuario.ingresar_valor(8, 8, 1))
def jugar(self):
Interfaz.setear_titulo('Trabajo de Entrega Grupal')
Interfaz.alertar('Bienvenido!', 'Bienvenido al Trabajo de Entrega Grupal')
# Se selecciona el numero de jugadores y se crean los mismos:
self.configurar_el_juego()
# Se reparten los paises iniciales:
self.repartir_paises()
self.tablero.actualizar_interfaz()
# Se sortea que jugador iniciara el juego:
inicia_ronda = random.randrange(len(self.jugadores))
Interfaz.setear_texto("Ronda: %s" % self.texto_ronda(inicia_ronda))
# Primer refuerzo de ejercitos:
self.agregar_ejercitos_inicial(inicia_ronda)
# Bucle principal del juego:
while Interfaz.esta_corriendo():
# Para cada jugador en la ronda:
for i in range(len(self.jugadores)):
jugador = self.jugadores[(inicia_ronda + i) % len(self.jugadores)]
# El jugador puede haber muerto durante esta ronda:
if not self.jugador_esta_vivo(jugador):
continue
# El jugador juega su fase de ataques:
paises_ganados = self.realizar_fase_ataque(jugador)
# Se verifica si gano el juego:
if self.jugador_es_ganador(jugador):
Interfaz.alertar('Hay ganador!', 'El jugador %s ha ganado el juego' % jugador)
return
# El jugador realiza sus reagrupamientos:
self.realizar_fase_reagrupamiento(jugador)
# Se entrega la tarjeta y se verifica si ocupa
# algun pais del cual posee tarjeta.
self.manejar_tarjetas(jugador, paises_ganados)
# Si algun jugador hubiera perdido durante la ronda
# anterior se lo saca del juego:
for i in range(len(self.jugadores) - 1, -1, -1):
if not self.jugador_esta_vivo(self.jugadores[i]):
Interfaz.alertar('Uno menos!', 'El jugador %s ha quedado eliminado' % jugador)
self.jugadores.pop(i)
if inicia_ronda >= i:
inicia_ronda -= 1
# La siguiente ronda es iniciada por el siguiente jugador:
inicia_ronda = (inicia_ronda + 1) % len(self.jugadores)
Interfaz.setear_texto("Ronda: %s" % self.texto_ronda(inicia_ronda))
# Los jugadores refuerzan sus ejercitos:
self.agregar_ejercitos(inicia_ronda)
def test_interfaz_12(self):
usuario = Interfaz()
usuario.tamaño = 4
self.assertTrue(usuario.ingresar_valor(0, 0, 2))
def test_x(self):
user = Interfaz()
user.tam = 4
result = user.enter("x", 1, 1)
self.assertTrue(result)
def test_interfaz_13(self):
usuario = Interfaz()
usuario.tamaño = 4
self.assertFalse(usuario.ingresar_valor(6, 10, 4))
def test_symbold_and_char(self):
user = Interfaz()
result = user.enter("+", "g", 6)
self.assertFalse(result)
def test_interfaz_15(self):
usuario = Interfaz()
usuario.tamaño = 4
self.assertFalse(usuario.ingresar_valor(0, 2, 10))
cantidad_numero += i.count("'{0}'".format(tupla[0][0]))
return int(cantidad_numero)
def cantidad_subgrillas(self, tupla):
if tupla[0][0] not in tipo_ubicaciones or self.zoom != 6:
return "Acceso Prohibido"
contador = 0
contador_grillas = -1
subgrillas = 0
while contador < int(tupla[1][0]):
contador = self.cantidad_de_ubicacion(
([tupla[0][0]], [subgrillas]))
contador_grillas += 1
subgrillas += 1
if contador_grillas > 300:
return "El numero pedido no es posible"
return contador_grillas
if __name__ == '__main__':
sample = Sample()
funciones = [
sample.ubicaciones_por_region, sample.region_sin_ubicacion,
sample.ubicacion1_ubicacion2, sample.cantidad_de_ubicacion,
sample.cantidad_subgrillas
]
interfaz = Interfaz(sample.zooms, sample.moverse, sample.lista, funciones)
interfaz.full = False
interfaz.size = 4
interfaz.run()
def mostrar_canje_pais(self,pais,jugador):
"""Muestra por pantalla el pais canejado"""
Interfaz.setear_titulo("%s realizo canje: %s" % (jugador.su_nombre(),pais))
time.sleep(5)
self.tablero.actualizar_interfaz()
def test_Interfaz_6_valor_no_valido(self):
usuario = Interfaz()
usuario.tamaño = 9
self.assertFalse(usuario.ingresar_valor(6, 4, "ç"))
def test_Interfaz_3_columna_no_valida(self):
usuario = Interfaz()
usuario.tamaño = 9
self.assertFalse(usuario.ingresar_valor(4, "b", 2))
def test_Interfaz_7_columna_y_valor_no_valido(self):
usuario = Interfaz()
usuario.tamaño = 9
self.assertFalse(usuario.ingresar_valor(7, "c", "*"))
def test_Interfaz_8(self):
usuario = Interfaz()
usuario.tamaño = 9
self.assertTrue(usuario.ingresar_valor(7, 4, 5))
return int(cantidad_numero)
# Esta funcion retorna la cantidad de subgrillas que hay que moverse para encontrar un numero n de ubicaciones.
# En ella se ejecuta la funcion cantidad_de_ubicacion() para 0,1,...,n subgrillas y se cuentan las ubicaciones
# obtenidas para cada n, una vez q se cuentan mas ubicaciones de las ingresadas, se retorna el numero de subgrillas
def cantidad_subgrillas(self, tupla):
if tupla[0][0] not in tipo_ubicaciones or self.zoom != 6:
return "Acceso Prohibido"
contador = 0
contador_grillas = -1
subgrillas = 0
while contador < int(tupla[1][0]): #mientras el numero de ubicaciones contado sea menor al numero pedido
contador = self.cantidad_de_ubicacion(([tupla[0][0]], [subgrillas])) #se llama a la funcion anterior
contador_grillas += 1
subgrillas += 1
if contador_grillas > 300: #si ya se recorre el mapa entero (desde un extremo al otro) y no se llega a n
return "El numero pedido no es posible" #la funcion se detiene
return contador_grillas
if __name__ == '__main__':
main = Main()
funciones = [main.ubicaciones_por_region, main.region_sin_ubicacion,
main.ubicacion1_ubicacion2, main.cantidad_de_ubicacion, main.cantidad_subgrillas]
interfaz = Interfaz(
main.zooms, main.moverse, main.lista, funciones)
interfaz.full = False
interfaz.size = 4
interfaz.run()
def test_interfaz_9(self):
usuario = Interfaz()
usuario.tamaño = 9
self.assertTrue(usuario.ingresar_valor(1, 3, 1))
def __init__(self):
self.lista = [[0 for y in range(32)] for x in range(36)]
def func_alumno1(self, num):
valor = 38 - num if num < 32 else 2
self.lista = [[0 for y in range(valor)] for x in range(valor)]
return self.lista
def func_alumno2(self, tupla):
return self.lista
def consulta1(self, tupla):
return ["Respuesta1", "Respuesta2", tupla]
def consulta5(self, tupla):
return 1
if __name__ == '__main__':
sample = Sample()
funciones = [
sample.consulta1, sample.consulta1, sample.consulta1, sample.consulta5,
sample.consulta5
]
interfaz = Interfaz(sample.func_alumno1, sample.func_alumno2, sample.lista,
funciones)
# Modificar
interfaz.full = False
interfaz.size = 9
interfaz.run()
class Sample:
def __init__(self):
self.lista = [[0 for y in range(32)] for x in range(36)]
def func_alumno1(self, num):
valor = 38 - num if num < 32 else 2
self.lista = [[0 for y in range(valor)] for x in range(valor)]
return self.lista
def func_alumno2(self, tupla):
return self.lista
def consulta1(self, tupla):
return ["Respuesta1", "Respuesta2", tupla]
def consulta5(self, tupla):
return 1
if __name__ == '__main__':
sample = Sample()
funciones = [sample.consulta1, sample.consulta1,
sample.consulta1, sample.consulta5, sample.consulta5]
interfaz = Interfaz(
sample.func_alumno1, sample.func_alumno2, sample.lista, funciones)
# Modificar
interfaz.full = False
interfaz.size = 9
interfaz.run()
