def run(self):
self.__is_running = True
while self.__is_running:
self.__print_menu()
option = int(input(" >> "))
if option == 0:
self.__map.load_from_binary_file("../assets/test1.map")
if option == 1:
self.__map.load_from_binary_file("../assets/test1.map")
self.__controller = Controller(self.__map)
self.__controller.run()
elif option == 2:
self.do_before_running_gui()
fittest_individual = self.__controller.fittest_individual
gene_index = 0
self.__is_running_gui = True
time.sleep(1)
while self.__is_running_gui:
if gene_index < INDIVIDUAL_SIZE:
self.__is_running_gui = self.__gui.render(
gene_index, fittest_individual)
gene_index += 1
time.sleep(0.5)
self.__gui.quit()
elif option == 3:
pass
elif option == 4:
self.visualize_map()
def _atualiza_aluno(argumentos):
aluno_id = "--aluno-id"
situacao = "--situacao"
nome = "--nome"
materia = "--materia"
nota = "--nota"
aluno = Aluno()
try:
if aluno_id in argumentos:
id_ = _pega_valor(argumentos, aluno_id)
Controller(aluno, bd).atualiza(id_)
if nome in argumentos:
nome_ = _pega_valor(argumentos, nome)
aluno.define_nome(nome_)
Controller(aluno, bd).atualiza(id_)
if situacao in argumentos:
situacao_ = _pega_valor(argumentos, situacao)
aluno.define_situacao(situacao_)
Controller(aluno, bd).atualiza(id_)
if materia in argumentos and nota in argumentos:
materia_ = _pega_valor(argumentos, materia)
nota_ = _pega_valor(argumentos, nota)
materias = {materia_: nota_}
aluno.atualiza_materias_cursadas(materias)
Controller(aluno, bd).atualiza(id_)
print(f"Aluno com identificador {id_} atualizado com sucesso.")
except Exception:
raise
def run(self):
self.__is_running = True
while self.__is_running:
self.__print_menu()
option = int(input(" >> "))
if option == 0:
self.__map.load_from_binary_file("../assets/test1.map")
if option == 1:
self.__controller = Controller(self.__map)
self.best_solution = self.__controller.run()
print("--------------- BEST SOLUTION -------------------- \n")
print("--- Best Solution fitness: ", self.best_solution[0])
print("--- Best Solution path: ", end=" ")
for s in self.best_solution[1]:
print("(", s.x, ", ", s.y, ") ", end=" ")
elif option == 2:
self.do_before_running_gui()
self.__is_running_gui = True
time.sleep(1)
index = 0
while self.__is_running_gui:
self.__is_running_gui = self.__gui.render(
self.best_solution, index)
index += 1
time.sleep(0.2)
self.__gui.quit()
elif option == 3:
pass
elif option == 4:
self.visualize_map()
def setup(self):
"""
setup the attributes of this gameengine\n
:return:
"""
Controller.setup(self)
self.__create_memento()
n_cpus = resource.get_value("n_cpus")
packet_val_min = resource.get_value("packet_val_min")
packet_val_max = resource.get_value("packet_val_max")
self.__trash = Trash()
trash_dimen = resource.get_dimen("trash")
self.__trash.set_pos(trash_dimen.x, trash_dimen.y)
# generates cpus with unique values
vals = tools.unique_vals(n_cpus, packet_val_min, packet_val_max)
for val in vals:
self.__cpus.append(CPU(val))
for i in range(0, resource.get_value("buffer_size_start")):
self.add_packet()
player_dimen = resource.get_dimen("player")
self.__player.set_pos(player_dimen.x, player_dimen.y)
def make_copy(self):
for x in self.winfo_children():
if (x.winfo_ismapped()):
self._copie.append(x)
self.stop_display(
) #In order to display the elements again, we refresh the frame
Controller.display_played_cards(self, True) #Display the cards played
def test_aluno_pode_atualizar_situacao(self, cria_curso_materias_real):
aluno, curso, _ = cria_curso_materias_real
expected = "trancado"
Controller(InscricaoAlunoCurso(aluno, curso), self.bd).salva()
self._atualiza_aluno_por_cli(aluno.pega_id(), situacao=expected)
aluno = Controller(Aluno(), self.bd).pega_registro_por_id(aluno.pega_id())
actual = aluno.pega_situacao()
assert actual == expected
def test_curso_criado_banco_dados(self, cria_banco):
curso_id = 1
expected = Curso(curso_nome_1).pega_nome()
controller = Controller(Curso(curso_nome_1), cria_banco)
controller.salva()
curso = controller.pega_registro_por_id(curso_id)
actual = curso.pega_nome()
assert actual == expected
def test_cria_materia_por_cli(self, cria_banco_real):
nome = materia_nome_1
expected = nome
parametros = ["cria-materia", "--nome", nome]
executa_comando(parametros)
materia = Materia(nome)
registro = Controller(materia, cria_banco_real).pega_registros()[0]
actual = registro.pega_nome()
assert actual == expected
def cria_massa_dados(cria_banco_real):
bd = cria_banco_real
bd.deleta_tabela(cursos)
bd.deleta_tabela(alunos)
aluno_id = Controller(Aluno(aluno_nome_1), bd).salva()
curso_id = Controller(Curso(curso_nome_1), bd).salva()
yield aluno_id, curso_id
bd.deleta_tabela(cursos)
bd.deleta_tabela(alunos)
def test_aluno_pode_atualizar_nome(self, cria_massa_dados):
cria_massa_dados
aluno_id = "1"
nome = aluno_nome_2
expected = nome
self._atualiza_aluno_por_cli(aluno_id, nome)
aluno = Controller(Aluno(), self.bd).pega_registro_por_id(aluno_id)
actual = aluno.pega_nome()
assert actual == expected
def retour(self):
self.stop_display() #Updates
if (self._copie[0] is
self._prince_frames[0]): #Search which info were displayed
Controller.display_prince_choice(
self._copie[0].winfo_children()[0]['text'],
self._copie[1].winfo_children()[0]['text'])
else:
Controller.display_guard_choice()
self._copie = [] #Clear the buffer
def _cria_curso(argumentos):
nome_parametro = "--nome"
materias_parametro = "--materias"
numero_argumentos = 8
if nome_parametro in argumentos and materias_parametro in argumentos \
and len(argumentos) == numero_argumentos:
try:
nome = _pega_valor(argumentos, nome_parametro)
materia_1 = _pega_valor(argumentos, materias_parametro)
materia_2 = _pega_valor(argumentos, materias_parametro, 2)
materia_3 = _pega_valor(argumentos, materias_parametro, 3)
curso = Curso(nome)
controller_curso = Controller(curso, bd)
controller_curso.salva()
registro = controller_curso.pega_registro_por_nome(nome)
curso_id = registro.pega_id()
controller = Controller(Materia(None), bd)
for materia in [materia_1, materia_2, materia_3]:
registro = controller.pega_registro_por_nome(materia)
materia_id = registro.pega_id()
curso.atualiza_materias(Materia(materia))
Controller(AssociaCursoMateria(curso_id, materia_id),
bd).salva()
print(f"Curso de {curso.pega_nome()} criado.")
except Exception:
raise
else:
raise ListaParametrosInvalida(LISTA_PARAMETROS_INVALIDA)
def _cria_aluno(argumentos):
nome_parametro = "--nome"
numero_parametros = 4
if nome_parametro in argumentos and len(argumentos) == numero_parametros:
nome = _pega_valor(argumentos, nome_parametro)
aluno = Aluno(nome)
controller = Controller(aluno, bd)
controller.salva()
print(f"Aluno {nome} criado com sucesso.")
else:
raise ListaParametrosInvalida(LISTA_PARAMETROS_INVALIDA)
def test_aluno_inscrito_curso_salvo_banco_dados(self, cria_banco_real):
Controller(Aluno(aluno_nome_1), cria_banco_real).salva()
Controller(Curso(curso_nome_1), cria_banco_real).salva()
expected = [tuple((1, self.aluno_id, self.curso_id))]
parametros = [
"inscreve-aluno-curso", "--aluno-id", self.aluno_id, "--curso-id",
self.curso_id
]
executa_comando(parametros)
inscricao = InscricaoAlunoCurso(self.aluno_id, self.curso_id)
actual = Controller(inscricao, cria_banco_real).pega_registros()
assert actual == expected
class EnviarPacote():
def __init__(self, dispositivo):
self.__controller = Controller()
self.__dispositivo = dispositivo
def enviar(self, pacote):
try:
self.__dispositivo.escreverPorta(pacote)
self.__controller.visualizar().enviado()
except Exception:
self.__controller.visualizar().erro()
def test_curso_criado_banco_dados(self):
self._cria_materias()
expected = Curso(curso_nome_1).pega_nome()
parametros = [
self._cria_curso, "--nome", curso_nome_1, "--materias",
materia_nome_1, materia_nome_2, materia_nome_3
]
executa_comando(parametros)
curso = Controller(Curso(curso_nome_1),
self._bd).pega_registros()[self.first]
actual = curso.pega_nome()
assert actual == expected
def __init__(self):
"""
initialize gameengine\n
defines screen and init pygame
"""
Controller.__init__(self)
self.__player = Player()
self.__buffer = Buffer(resource.get_value("buffer_capacity"))
self.__cpus = []
self.__pending_packet = []
self.__endstate = EndState()
def test_situaca_aluno_muda_para__em_curso__apos_inscricao(
self, cria_banco_real):
Controller(Aluno(aluno_nome_1), cria_banco_real).salva()
Controller(Curso(curso_nome_1), cria_banco_real).salva()
expected = "em curso"
parametros = [
"inscreve-aluno-curso", "--aluno-id", self.aluno_id, "--curso-id",
self.curso_id
]
executa_comando(parametros)
InscricaoAlunoCurso(self.aluno_id, self.curso_id)
aluno = Controller(Aluno().define_id(self.aluno_id),
cria_banco_real).pega_registro_por_id(self.aluno_id)
actual = aluno.pega_situacao()
assert actual == expected
class Dispositivo():
def __init__(self):
self.controller = Controller()
self.porta = self.escolhaPorta()
def escolhaPorta(self):
MAX_PORTAS = 10 # numero maximo de portas
k = 1
#configuracao da porta
baudrate = 9600
bytesize = 8
parity = 'N'
stopbits = 1
timeout = 0
#controle de fluxo
xonxoff = False
rtscts = False
dict = {}
for p in ['COM%s' % (i + 1) for i in range(MAX_PORTAS)]:
try:
s = Serial(p)
dict[k] = s.portstr
k += 1
s.close()
except (OSError, SerialException):
pass
for i in dict:
print i, " - ", dict[i]
p = 15
if len(dict) == 0:
self.controller.visualizar().semPorta()
sys.exit(0)
else:
while (p not in dict):
p = int(input("\nEscolha a porta serial: "))
if p <= len(dict) and p != 0:
try:
self.porta = Serial(dict[p], baudrate, bytesize,
parity, stopbits, timeout, xonxoff,
rtscts)
self.controller.visualizar().portaEscolhida(
self.porta.portstr)
return self.porta
except SerialException:
self.controller.visualizar().erro()
sys.exit(0)
else:
self.controller.visualizar().portaSemExistencia()
def ouvirPorta(self):
return self.porta.read(256)
def escreverPorta(self, pacote):
return self.porta.write(pacote)
def main():
environment_repository = EnvironmentRepository()
image_repository = ImageRepository()
controller = Controller(environment_repository, image_repository)
gui = GUI(controller)
gui.start()
def main():
view = View()
ctrl = Controller(view)
view.inject_controller(ctrl)
if len(sys.argv) > 1:
view.onecmd(' '.join(sys.argv[1:]))
view.cmdloop()
def test_retorna_excecao_quando_curso_id_nao_existe(self, cria_banco_real):
expected = "Curso não encontrado."
Controller(Aluno(None), cria_banco_real).salva()
parametros = [
"inscreve-aluno-curso", "--aluno-id", self.aluno_id, "--curso-id",
self.curso_id
]
actual = executa_comando(parametros)
assert expected in actual
class Dispositivo():
def __init__(self):
self.controller = Controller()
self.porta = self.escolhaPorta()
def escolhaPorta(self):
MAX_PORTAS = 10 # numero maximo de portas
k = 1
#configuracao da porta
baudrate = 9600
bytesize = 8
parity = 'N'
stopbits = 1
timeout = 0
#controle de fluxo
xonxoff = False
rtscts = False
dict = {}
for p in ['COM%s' % (i + 1) for i in range(MAX_PORTAS)]:
try:
s = Serial(p)
dict[k] = s.portstr
k+=1
s.close()
except (OSError, SerialException):
pass
for i in dict:
print i, " - ", dict[i]
p = 15
if len(dict) == 0:
self.controller.visualizar().semPorta()
sys.exit(0)
else:
while(p not in dict):
p = int(input("\nEscolha a porta serial: "))
if p <= len(dict) and p!=0:
try:
self.porta = Serial(dict[p], baudrate, bytesize, parity, stopbits, timeout, xonxoff, rtscts)
self.controller.visualizar().portaEscolhida(self.porta.portstr)
return self.porta
except SerialException:
self.controller.visualizar().erro()
sys.exit(0)
else:
self.controller.visualizar().portaSemExistencia()
def ouvirPorta(self):
return self.porta.read(256)
def escreverPorta(self, pacote):
return self.porta.write(pacote)
def _cria_materia(argumentos):
nome = "--nome"
numero_argumentos = 4
if nome in argumentos and len(argumentos) == numero_argumentos:
nome = _pega_valor(argumentos, nome)
materia = Materia(nome)
Controller(materia, bd).salva()
print(f"Matéria de {materia.pega_nome()} criada.")
else:
raise ListaParametrosInvalida(LISTA_PARAMETROS_INVALIDA)
class Console(object):
def __init__(self):
self.__is_running = False
self.__is_running_gui = False
self.__map = Map()
self.__gui: Gui = Gui(self.__map)
self.__controller: Controller = None
def do_before_running_gui(self):
self.__gui.initialize()
def visualize_map(self):
self.do_before_running_gui()
self.__is_running_gui = True
while self.__is_running_gui:
self.__is_running_gui = self.__gui.render()
self.__gui.quit()
def run(self):
self.__is_running = True
while self.__is_running:
self.__print_menu()
option = int(input(" >> "))
if option == 0:
self.__map.load_from_binary_file("../assets/test1.map")
if option == 1:
self.__controller = Controller(self.__map)
self.best_solution = self.__controller.run()
print("--------------- BEST SOLUTION -------------------- \n")
print("--- Best Solution fitness: ", self.best_solution[0])
print("--- Best Solution path: ", end=" ")
for s in self.best_solution[1]:
print("(", s.x, ", ", s.y, ") ", end=" ")
elif option == 2:
self.do_before_running_gui()
self.__is_running_gui = True
time.sleep(1)
index = 0
while self.__is_running_gui:
self.__is_running_gui = self.__gui.render(
self.best_solution, index)
index += 1
time.sleep(0.2)
self.__gui.quit()
elif option == 3:
pass
elif option == 4:
self.visualize_map()
@staticmethod
def __print_menu():
print("0. load map\n"
"1. run EA\n"
"2. visualize solution\n", "3. view statistics\n"
"4. view map\n")
def cria_massa_dados_em_memoria(cria_banco):
Controller(Aluno(aluno_nome_1), cria_banco).salva()
Controller(Curso(curso_nome_1), cria_banco).salva()
Controller(Materia(materia_nome_1), cria_banco).salva()
Controller(Materia(materia_nome_2), cria_banco).salva()
Controller(Materia(materia_nome_3), cria_banco).salva()
Controller(AssociaCursoMateria(curso_id=1, materia_id=1),
cria_banco).salva()
Controller(AssociaCursoMateria(curso_id=2, materia_id=1),
cria_banco).salva()
Controller(AssociaCursoMateria(curso_id=3, materia_id=1),
cria_banco).salva()
Controller(InscricaoAlunoCurso(aluno_id=1, curso_id=1), cria_banco)
yield
cria_banco.deleta_tabela(cursos)
cria_banco.deleta_tabela(alunos)
def test_aluno_pode_ser_inscrito_curso(self, cria_banco_real,
cria_curso_banco_real):
expected = (f"Aluno identificado por {self.aluno_id} inscrito no curso"
f" identificado por {self.curso_id}.")
Controller(Aluno(None), cria_banco_real).salva()
cria_curso_banco_real
parametros = [
"inscreve-aluno-curso", "--aluno-id", self.aluno_id, "--curso-id",
self.curso_id
]
actual = executa_comando(parametros)
assert actual == expected
def testProgram(self):
try:
rv = Controller.playGame('Player', 'Scissor', 'Scissor')
assert ('It is a draw!', 'Scissor',
'Scissor') == rv, "Scissor and Scissor is a draw!"
rv = Controller.playGame('Player', 'Scissor', 'Rock')
assert ('Player lost!', 'Scissor',
'Rock') == rv, "Rock breaks the scissor!"
rv = Controller.playGame('Player', 'Scissor', 'Paper')
assert ('Player won!', 'Scissor',
'Paper') == rv, "Scissor cuts the paper!"
rv = Controller.playGame('Player 2', 'Paper', 'Rock')
assert ('Player 2 won!', 'Paper',
'Rock') == rv, "Paper wraps the rock!"
rv = Controller.playGame('Player')
assert (
mock.ANY, mock.ANY, mock.ANY
) == rv, "Random moves should be generated for both Player and Computer 1!"
rv = Controller.playGame('Player', 'Rock')
assert (
mock.ANY, mock.ANY, mock.ANY
) == rv, "A random move should be generated for Computer 1!"
return "Passes all checks!"
except AssertionError as e:
return str(e.args)
class RecebedorPacote():
def __init__(self, dispositivo):
self.__dispositivo = dispositivo
self.__controller = Controller()
self.__lista = []
self.__ok = True
def iniciarThread(self):
self.__controller.visualizar().aguardandoPacote()
try:
t1 = Thread(target=self.receberPacote)
t1.start()
except Exception as e:
print e
def terminarThread(self):
self.__controller.visualizar().pararGerador()
self.__ok = False
def getLista(self):
temp = self.__lista
self.__lista = []
return temp
def receberPacote(self):
while self.__ok:
try:
data = self.__dispositivo.ouvirPorta()
if len(data) > 0:
self.__lista.append(data)
except Exception:
self.__controller.visualizar().erro()
class RecebedorPacote():
def __init__(self, dispositivo):
self.__dispositivo = dispositivo
self.__controller = Controller()
self.__lista = []
self.__ok = True
def iniciarThread(self):
self.__controller.visualizar().aguardandoPacote()
try:
t1 = Thread(target=self.receberPacote)
t1.start()
except Exception as e:
print e
def terminarThread(self):
self.__controller.visualizar().pararGerador()
self.__ok = False
def getLista(self):
temp = self.__lista
self.__lista = []
return temp
def receberPacote(self):
while self.__ok:
try:
data = self.__dispositivo.ouvirPorta()
if len(data) > 0:
self.__lista.append(data)
except Exception:
self.__controller.visualizar().erro()
def init_playersUI(self, theme1):
#Buttons coresponding to the displaying of the hand of the AI (purely visual)
self._ia_labels = (tk.Label(self,
image=self._images["Cache"],
borderwidth=0,
highlightthickness=0),
tk.Label(self,
image="",
borderwidth=0,
highlightthickness=0,
bg=theme1),
tk.Label(self,
image="",
borderwidth=0,
highlightthickness=0,
bg=theme1))
self._ia_labels[0].place(rely=0,
relx=0.5,
x=-self._ia_labels[0].winfo_reqwidth())
#Buttons of the user, used to chose the card to play
self._player_buttons = (
tk.Button(self,
command=lambda: Controller.card_played(self, 0),
borderwidth=0,
highlightthickness=0),
tk.Button(self,
command=lambda: Controller.card_played(self, 1),
borderwidth=0,
highlightthickness=0),
tk.Button(self,
command=lambda: Controller.card_played(self, 2),
borderwidth=0,
highlightthickness=0))
#The 3d button is here to handle the counselor case
self._player_buttons[0].place(rely=1,
relx=0.5,
x=-self._ia_labels[0].winfo_reqwidth(),
y=-self._ia_labels[0].winfo_reqheight())
def index():
# execute this when the client first joins the game through the 'GET' method
if request.method == 'GET':
session.clear()
session['opponent'] = "Computer 1"
session['round'] = 1
session['p1Win'] = 0
session['p2Win'] = 0
# show the main menu
return render_template('main.html')
# subsequent requests would be done through the 'POST' method
else:
response = request.form['option']
# navigate to the page that show the available moves
if response == 'Player' or response == 'Computer 2':
session[
'player'] = response # store player name (i.e. Player / Computer 2)
return render_template('battle.html', player=response)
# navigate to the page to show the winner
elif response in moveType:
result, _, opponentMove = Controller.playGame(
session['player'], response)
return render_template('result.html',
result=result,
playerMove=response,
opponentMove=opponentMove)
# random (comp vs. comp)
else:
result, playerMove, opponentMove = Controller.playGame(
session['player'])
return render_template('result.html',
result=result,
playerMove=playerMove,
opponentMove=opponentMove)
def __init__(self, dispositivo):
self.__dispositivo = dispositivo
self.__controller = Controller()
self.__lista = []
self.__ok = True
def __init__(self):
self.controller = Controller()
self.porta = self.escolhaPorta()
def __init__(self, dispositivo):
self.__dispositivo = dispositivo
self.__enviarPacote = EnviarPacote(self.__dispositivo)
self.__pacotesGerados = PacotesGerados()
self.__geradorPacote = GeradorPacote(self.__pacotesGerados)
self.__controller = Controller()
class ExperimentoElisa(object):
def __init__(self, dispositivo):
self.__dispositivo = dispositivo
self.__enviarPacote = EnviarPacote(self.__dispositivo)
self.__pacotesGerados = PacotesGerados()
self.__geradorPacote = GeradorPacote(self.__pacotesGerados)
self.__controller = Controller()
def transformador(self, pacote):
f = ''
for i in pacote:
f += i
respostaOBC = [ord(b) for b in f]
if len(respostaOBC) > 1:
print respostaOBC
self.pacotesRecebidos(respostaOBC)
def pacotesRecebidos(self, respostaOBC):
if respostaOBC[2] == 11:
self.__controller.visualizar().turnOn()
self.__enviarPacote.enviar(self.__geradorPacote.acknowledge())
self.__geradorPacote.iniciarThread()
self.__controller.visualizar().geradorIniciando()
elif respostaOBC[2] == 1:
self.__controller.visualizar().dataRequest()
a = self.__pacotesGerados.getListaPacotes()
self.__enviarPacote.enviar(a)
print a
elif respostaOBC[2] == 2:
self.__controller.visualizar().dataSend()
self.__enviarPacote.enviar(self.__geradorPacote.acknowledge())
if respostaOBC[4] == 0:
self.__controller.visualizar().tempoZero()
self.__geradorPacote.mudarTempo(0x0)
else:
self.__controller.visualizar().tempoUm()
self.__geradorPacote.mudarTempo(0x1)
elif respostaOBC[2] == 7:
self.__controller.visualizar().reset()
self.__enviarPacote.enviar(self.__geradorPacote.acknowledge())
self.__geradorPacote.varredura = 0x0
self.__geradorPacote.mudarTempo(0x0)
self.__pacotesGerados.listaPacotes = []
elif respostaOBC[2] == 9:
self.__controller.visualizar().turnOff()
self.__enviarPacote.enviar(self.__geradorPacote.acknowledge())
self.__geradorPacote.terminarThread()
RecebedorPacote(self.__dispositivo).terminarThread()
else:
self.__controller.visualizar().erro()
