Example #1
0
    def registrar(self, nome_canal, nome_jogador, objeto_jogador):
        if not nome_canal or not nome_jogador:
            raise ValueError("Nome de canal/jogador inválido!!!")

        if nome_jogador in self.nomes_jogadores_conectados:
            raise ValueError("Esse nome de jogador já está sendo usado!!!")

        if nome_canal not in self.canais_de_comunicacao:
            print(f"Criando novo canal {nome_canal}")
            self.canais_de_comunicacao[nome_canal] = []

        sou_o_primeiro_jogador = False
        if not self.nomes_jogadores_conectados:
            sou_o_primeiro_jogador = True

        self.canais_de_comunicacao[nome_canal].append((nome_jogador, objeto_jogador))
        self.nomes_jogadores_conectados.append(nome_jogador)
        print(f"Jogador {nome_jogador} se conectou no canal {nome_canal}")

        mensagem_de_conexao = Mensagem(
            tipo="conexao_estabelecida",
            conteudo=sou_o_primeiro_jogador,
            remetente="servidor",
        )
        self.publicar(
            nome_canal,
            "SERVER",
            mensagem_de_conexao.converter_msg_em_dict_para_enviar(),
        )

        return [
            nome_jogador for (nome_jogador, c) in self.canais_de_comunicacao[nome_canal]
        ]
Example #2
0
	def desempacotaMensagem(self,mensagem,porta):
		aplicacao = portas[porta]
		respostaCorreta = aplicacao.recebeMensagem(mensagem)
		if respostaCorreta:
		   m = Mensagem()
		   m.setMsg(getNoBuffer())
		   return m
Example #3
0
    def desconectar_jogador(self, nome_canal, nome_jogador):
        if nome_canal not in self.canais_de_comunicacao:
            print(f"CANAL DESCONHECIDO IGNORADO {nome_canal}")
            return

        for (n, c) in self.canais_de_comunicacao[nome_canal]:
            if n == nome_jogador:
                self.canais_de_comunicacao[nome_canal].remove((n, c))
                break

        mensagem_de_conexao = Mensagem(
            tipo="desistencia",
            conteudo=f"\n** {nome_jogador} saiu do jogo **",
            remetente=nome_jogador,
        )
        self.publicar(
            nome_canal,
            "SERVER",
            mensagem_de_conexao.converter_msg_em_dict_para_enviar(),
        )

        if len(self.canais_de_comunicacao[nome_canal]) < 1:
            del self.canais_de_comunicacao[nome_canal]
            print(f"Canal {nome_canal} removido")

        self.nomes_jogadores_conectados.remove(nome_jogador)
        print(f"O jogador {nome_jogador} deixou o canal {nome_canal}")
    def enviar_mensagem_para_o_servidor(self):
        while True:
            mensagem_para_enviar = ""
            try:
                mensagem_para_enviar = input(f"{self.nome} > ")
            except KeyboardInterrupt:
                self.encerrar_conexao_servidor()

            if mensagem_para_enviar:
                if mensagem_para_enviar in ["sair do jogo", "desconectar"]:
                    mensagem_desistencia = Mensagem(
                        tipo="desistencia",
                        conteudo="Você ganhou a partida",
                        remetente=self.nome,
                    )
                    mensagem_em_bytes = (mensagem_desistencia.
                                         converter_msg_em_bytes_para_enviar())
                    self.conexao.send(mensagem_em_bytes)
                    self.encerrar_conexao_servidor()
                    break
                else:
                    mensagem = Mensagem(tipo="chat",
                                        conteudo=mensagem_para_enviar,
                                        remetente=self.nome)
                    mensagem_em_bytes = mensagem.converter_msg_em_bytes_para_enviar(
                    )
                    self.conexao.send(mensagem_em_bytes)
    def iniciar_conexao_com_servidor(self):
        self.conexao = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.conexao.connect((self.endereco_ip, self.porta))
        self.conexao.setblocking(False)

        mensagem_inicial = Mensagem(tipo="chat",
                                    conteudo=self.nome,
                                    remetente=self.nome)
        mensagem_em_bytes = mensagem_inicial.converter_msg_em_bytes_para_enviar(
        )
        self.conexao.send(mensagem_em_bytes)
    def receber_mensagens_do_servidor(self):
        while True:
            try:
                mensagem_recebida_do_servidor = self.conexao.recv(
                    TAMANHO_MAX_MSG)

                if not len(mensagem_recebida_do_servidor):
                    print("Conexão fechada pelo servidor!")
                    self.encerrar_conexao_servidor()

                mensagem = Mensagem(tipo="chat",
                                    conteudo="",
                                    remetente=self.nome)
                mensagem.converter_bytes_para_json_e_setar_valores_da_classe(
                    json_em_bytes=mensagem_recebida_do_servidor)

                if mensagem.tipo == TipoPermitidosDeMensagem.desistencia.value:
                    print("Eu venci a partida, ieeeeeeei")
                    self.encerrar_conexao_servidor()
                elif (mensagem.tipo ==
                      TipoPermitidosDeMensagem.conexao_estabelecida.value):
                    if mensagem.conteudo:
                        print("sou o primeiro jogador")
                        self.sou_primeiro_jogador = True
                    else:
                        print("sou o segundo jogador")
                elif mensagem.tipo == TipoPermitidosDeMensagem.movimentacao.value:
                    tela_do_jogador.sincronizacao_de_valor_de_pecas_do_meu_tabuleiro_com_o_outro_jogador(
                        mensagem.conteudo)
                else:
                    print(
                        f"\n{mensagem.remetente} > {mensagem.conteudo}\n{self.nome} > ",
                        end="",
                    )

            except IOError as e:
                if e.errno != errno.EAGAIN and e.errno != errno.EWOULDBLOCK:
                    print("Reading error: {}".format(str(e)))
                    sys.exit()

                continue

            except Exception as e:
                print("Reading error: ".format(str(e)))
                sys.exit()
Example #7
0
 def desconectar(self):
     mensagem: Mensagem = Mensagem(
         tipo="desistencia",
         conteudo="Você ganhou a partida",
         remetente=self.nome_jogador,
     )
     self.servidor.publicar(
         self.canal_de_comunicacao,
         self.nome_jogador,
         mensagem.converter_msg_em_dict_para_enviar(),
     )
     self.servidor.desconectar_jogador(self.canal_de_comunicacao,
                                       self.nome_jogador)
     self.conexao_encerrada = 1
     self._pyroDaemon.shutdown()
Example #8
0
    def receber_mensagem(self, nome_jogador: str, mensagem: dict):
        if nome_jogador != self.nome_jogador:
            mensagem_recebida_do_servidor = Mensagem(
                tipo="chat", conteudo="", remetente=self.nome_jogador)
            mensagem_recebida_do_servidor.setar_valores_da_classe(
                json_da_mensagem=mensagem)

            if (mensagem_recebida_do_servidor.tipo ==
                    TipoPermitidosDeMensagem.desistencia.value):
                self.historico_de_mensagens += "\nEu venci a partida, ieeeeeeei.\nVocê já pode encerrar a sua partida :D"
            elif (mensagem_recebida_do_servidor.tipo ==
                  TipoPermitidosDeMensagem.conexao_estabelecida.value):
                if mensagem_recebida_do_servidor.conteudo:
                    self.sou_primeiro_jogador = True
            elif (mensagem_recebida_do_servidor.tipo ==
                  TipoPermitidosDeMensagem.movimentacao.value):
                self.tela_do_jogador.sincronizacao_de_valor_de_pecas_do_meu_tabuleiro_com_o_outro_jogador(
                    mensagem_recebida_do_servidor.conteudo)

            else:
                self.historico_de_mensagens += mensagem_recebida_do_servidor.conteudo

            os.system("clear")
            print(self.historico_de_mensagens)
Example #9
0
    def controlador_da_partida(self):
        mostrar_tela_jogo = True
        while mostrar_tela_jogo:
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    mostrar_tela_jogo = False

            if event.type == pygame.MOUSEBUTTONDOWN:
                if pygame.mouse.get_pressed()[0]:
                    resultado = self.tela_do_jogador.clicou_em_alguma_das_minhas_casa(
                        pygame.mouse.get_pos())
                    time.sleep(0.5)
                    if resultado:
                        novos_valores_pecas_tabuleiro = (
                            self.tela_do_jogador.
                            pegar_os_valores_das_casas_e_kallah())

                        mensagem_movimentacao = Mensagem(
                            tipo=TipoPermitidosDeMensagem.movimentacao.value,
                            conteudo=novos_valores_pecas_tabuleiro,
                            remetente=self.nome_jogador,
                        )

                        self.servidor.publicar(
                            self.canal_de_comunicacao,
                            self.nome_jogador,
                            mensagem_movimentacao.
                            converter_msg_em_dict_para_enviar(),
                        )
                        resultado = False
                        continue

            terminou = self.tela_do_jogador.verficar_se_alguem_ganhou()
            if terminou:
                mostrar_tela_jogo = False

            self.tela_do_jogador.desenhar_elementos_na_tela()
            self.tela_do_jogador.mostrar_tela_do_jogador()
Example #10
0
 def enviar_mensagem_de_chat(self):
     try:
         try:
             while not self.conexao_encerrada:
                 pass
                 msg = input(f"{self.nome_jogador}> ").strip()
                 if msg == "/sair":
                     break
                 if msg:
                     self.historico_de_mensagens += f"\n{self.nome_jogador} > {msg}"
                     mensagem: Mensagem = Mensagem(
                         tipo="chat",
                         conteudo=f"\n{self.nome_jogador} > {msg}",
                         remetente=self.nome_jogador,
                     )
                     self.servidor.publicar(
                         self.canal_de_comunicacao,
                         self.nome_jogador,
                         mensagem.converter_msg_em_dict_para_enviar(),
                     )
         except EOFError:
             pass
     finally:
         self.desconectar()
Example #11
0
            conn = my_accept()
            print "Estabilished connection with", conn

        # recebe mensagens exclusivamente desse cliente
        server_socket.settimeout(None)
        client_address = ""
        while (client_address != conn):
            message_serial, client_address = server_socket.recvfrom(2048)
            if client_address != conn:
                print "Ignored:", message_serial, "from:", client_address

        # finaliza a conexao com um cliente
        if message_serial == "END":
            conn = ""
            seq_num = 0
            print "Connection finished"
            continue

        # transforma a mensagem do cliente para uppercase e envia de volta
        print message_serial
        message = json.loads(message_serial)
        print "From client:", client_address, "Mensagem:", message['data']
        server_socket.settimeout(timeout_val)
        time.sleep(0.5)
        modified_mensagem = Mensagem(
            seq_num, message['data'].upper())
        print seq_num
        seq_num = seq_num + 1
        modified_mensagem_serial = json.dumps(modified_mensagem.__dict__)
        server_socket.sendto(modified_mensagem_serial, client_address)
Example #12
0
#-atribuindo enlaces
h0.setEnlace(e0)
h1.setEnlace(e1)
r0.setEnlace(0, e0)
r0.setEnlace(1, e1)
r0.rotas = rotas
r0.setTempoPacote('2')
elementos.append(h0)
elementos.append(h1)
elementos.append(r0)
elementos.append(e0)
elementos.append(e1)


# Datagrama
m = Mensagem()
m.setMsg("IRC MSG")
s = Segmento('UDP', 8888, 6667)
s.setMensagem(m)
d = Datagrama(6, h0.ip, h1.ip,s)
d.setTamanho(15)
d

# Envio
e0.enviar(h0, d)
e0.printBuff()

# Fila de comandos
h0.adicionaComando(2, "cmp", "sdajk")
h0.adicionaComando(8, "cmp", "lsjk")
h0.adicionaComando(1, "cmp", "ldajk")
Example #13
0
 def cmdUser(self, args):
     m = Mensagem()
     m.setMsg("USER " + str(args[0]) + " 8 *")
     self.envia(m)
Example #14
0
 def __montar_objeto_mensagem(self, tupla):
     return Mensagem(tupla['texto'], tupla['email_o'], tupla['email_d'])
Example #15
0
s1 = Servidor('gmail', dns)
s2 = Servidor('hotmail', dns)
s3 = Servidor('yahoo', dns)
dns.cadastrarServidor('gmail', s1)
dns.cadastrarServidor('hotmail', s2)
dns.cadastrarServidor('yahoo', s3)

c1 = Cliente('Luis', '123424', s1)
c2 = Cliente('Gustavo', '123424', s2)
c3 = Cliente('João', '123424', s3)

s1.cadastrarCliente(c1)
s2.cadastrarCliente(c2)
s3.cadastrarCliente(c3)

m1 = Mensagem('João', 'Luis', s1,'Aula do Menezes', \
             'Luís, hoje a aula vai ser maneira!!!!!')

m2 = Mensagem('Luis', 'Gustavo', s2 ,'Aula LP2', \
             'Gustavo, se prepara porque o joão folou que a aula vai der dahora!')

m3 = Mensagem('Gustavo', 'João',s3 ,'Aula de Python', \
             'João, como assim a aula vai ser maneira vai ser dificil?')

s1.receberMensagem(m1, 1234)

mensagens = s3.getMensagem()

for m in mensagens3:
    print(m)
Example #16
0
 def cmdQuit(self, args):
     m = Mensagem()
     m.setMsg(args[0])
     self.envia(m)
    def escutar_conexoes(self):
        while True:
            try:
                sockets_leitura, _, sockets_excecoes = select(
                    self.lista_conexoes, [], self.lista_conexoes
                )
            except KeyboardInterrupt:
                sys.exit("\nChat encerrado!")

            for conexao in sockets_leitura:
                if conexao == self.socket_servidor:
                    novo_cliente, infos_conexao = self.socket_servidor.accept()

                    mensagem = self.receber_mensagem_cliente(novo_cliente)
                    if mensagem is None:
                        continue

                    quantidade_conexoes = len(self.lista_conexoes)
                    self.lista_conexoes.append(novo_cliente)
                    self.clientes_conectados[novo_cliente] = novo_cliente

                    print(
                        "Nova conexão aceita {}:{}, username: {}".format(
                            *infos_conexao, mensagem.get("remetente")
                        )
                    )
                    conteudo_msg = ""
                    if (
                        not self.primeiro_jogador_se_conectou
                        and quantidade_conexoes == 1
                    ):
                        conteudo_msg = "Sim"
                        self.primeiro_jogador_se_conectou = True
                        print("o primeiro jogador conectou!")

                    mensagem_nova_conexao = Mensagem(
                        tipo="conexao_estabelecida",
                        conteudo=conteudo_msg,
                        remetente="servidor",
                    )
                    mensagem_nova_conexao = (
                        mensagem_nova_conexao.converter_msg_em_bytes_para_enviar()
                    )
                    novo_cliente.send(mensagem_nova_conexao)
                    print("mensagem enviada para a nova conexão")
                else:
                    mensagem_recebida = self.receber_mensagem_cliente(conexao)
                    if mensagem_recebida is None:
                        print("Fechando conexão de {}".format(conexao))
                        self.remover_conexao(conexao)
                        continue

                    print(
                        "Recebendo mensagem de {}: {}".format(
                            mensagem_recebida.get("remetente"),
                            mensagem_recebida.get("conteudo"),
                        )
                    )

                    for cliente in self.clientes_conectados:
                        if cliente != conexao:
                            cliente.send(
                                json.dumps(mensagem_recebida).encode(CODIFICACAO)
                            )

            for conexao in sockets_excecoes:
                self.remover_conexao(conexao)
Example #18
0
    def menu_feed(self, email, senha):
        self.email = email
        self.senha = senha
        self.user = self.buscar_usuario(email)
        print('FEED')
        print('1 - Publicar')
        print('2 - Adicionar amigo')
        print('3 - Buscar email de seu amigo')
        print('4 - Mudar profissão')
        print('5 - Listar minhas informações')
        print('6 - Desfazer amizade')
        print('7 - Listar amigos')
        print('8 - Alterar sua senha')
        print('9 - Excuir conta')
        print('10 - BATE-PAPO')
        print('11 - Adicionar anime com site')
        print('12 - Buscar anime ou site pelo nome')
        print('13 - Criar evento')
        print('14 - Listar eventos futuros')
        print('15 - Listar eventos passados ')
        print('x - Sair')

        opcao1 = input('Digite a opção (feed): ').lower()

        while opcao1 != 'x':

            if opcao1 == '1':
                texto = input('Texto: ')
                '''local=input('Local: ')
                amigo=input('Email Amigo: ')'''
                print(self.publicar(self.user, texto))

            if opcao1 == '2':
                email_amigo = input(
                    'Digite o email da pessoa que deseja adicionar: ').lower()
                self.usuarioDAO.inserir_amigo(self.email, email_amigo)
                print('Agora ' + str(self.buscar_usuario(email_amigo).nome) +
                      ' é seu amigo')

            if opcao1 == '3':
                nome_amigo = input('Digite o nome do seu amigo: ')
                print(self.buscar_amigo(nome_amigo))

            if opcao1 == '4':
                nova_profissao = input('Digite sua nova profissão: ')
                self.user.set_profissao(nova_profissao)
                self.usuarioDAO.set_profissao(nova_profissao, self.email)
                print('Agora sua nova profissao é ' + nova_profissao)

            if opcao1 == '5':
                print(self.usuarioDAO.listar_dados(self.email))

            if opcao1 == '6':
                email_amigo = input('Digite o email do seu amigo: ').lower()
                self.usuarioDAO.desfazer_amizade(self.email, email_amigo)
                print('Você desfez amizade com ' +
                      self.buscar_usuario(email_amigo).nome)

            if opcao1 == '7':
                for amigo in self.usuarioDAO.listar_amigos(self.user.email):
                    print(amigo)

            if opcao1 == '8':
                sua_senha = input('Digite sua senha: ')
                if sua_senha == self.senha:
                    n_senha = input('Digite a nova senha: ')
                    n_senha1 = input('Confirme a nova senha: ')
                    if n_senha != n_senha1:
                        print('As senhas não conferem')
                        n_senha = input('Digite a nova senha: ')
                        n_senha1 = input('Confirme a nova senha: ')
                    self.usuarioDAO.set_senha(self.email, n_senha)
                    print('Senha alterada com sucesso!')

            if opcao1 == '9':
                senha = input('Por questão de segurança digite sua senha: ')
                cursor = self.usuarioDAO.conexao.cursor()
                cursor.execute('SELECT * FROM login')
                for tupla in cursor.fetchall():
                    if str(tupla[0]) == str(email):
                        if str(tupla[1]) == self.senha:
                            self.usuarioDAO.excuir_conta(email)
                            print('Usuário excluído')
                            self.menu_inicial()
                        else:
                            print('Senha incorreta')

            if opcao1 == '10':
                print('BATE-PAPO')
                print('1 - Iniciar conversa')
                print('2 - Entrar em conversa')
                '''print('3 - Buscar mensagem')
                print('4 - Apagar conversa')
                print('5 - Apagar todas conversas')'''
                print('x - Voltar')
                opcao2 = input('Digite sua opção: ').lower()
                while opcao2 != 'x':
                    if opcao2 == '1':
                        email_d = input('Digite o email da pessoa: ')
                        texto = input('Digite a mensagem: ')
                        mensagem = Mensagem(texto, self.email, email_d)
                        self.mensagemDAO.enviar(mensagem)

                    if opcao2 == '2':
                        print('CONVERSAS')
                        for nome in self.mensagemDAO.nomes_conversas(
                                self.email):
                            print(str(nome[0]))
                        nome = input(
                            'Digite o nome da pessoa (Para sair digite x): ')
                        if nome == 'x':
                            self.menu_feed(self.email, self.senha)

                        pessoa = self.usuarioDAO.buscar_pelo_nome(nome)
                        if pessoa == False:
                            print('Nome incorreto')
                            opcao2 = '2'
                            return opcao2

                        self.conversa(pessoa, self.user)
                        conversar = input(
                            'Você deseja continuar conversa? sim ou nao: '
                        ).lower()
                        while conversar == 'sim':
                            texto = input('Digite a mensagem: ')
                            mensagem = Mensagem(texto, self.email,
                                                pessoa.email)
                            self.mensagemDAO.enviar(mensagem)
                            self.conversa(pessoa, self.user)
                            conversar = input(
                                'Você deseja continuar conversa? sim ou nao: ')

                    if opcao2 == '3':
                        pass

                    if opcao2 == '4':
                        pass

                    if opcao2 == '5':
                        pass

                    print('BATE-PAPO')
                    print('1 - Iniciar conversa')
                    print('2 - Entrar em conversa')
                    '''print('3 - Buscar mensagem')
                    print('4 - Apagar conversa')
                    print('5 - Apagar todas conversas')'''
                    print('x - Voltar')
                    opcao2 = input('Digite sua opção: ').lower()
                return self.menu_feed(self.email, self.senha)

            if opcao1 == '11':
                nome = input('Digite o nome do anime: ').lower()
                url = input('Digite a URL do site do anime: ')
                site = URL(url, nome)
                self.urlDAO.inserir(site)
                print('Anime cadastrado')

            if opcao1 == '12':
                nome = input('Digite o nome do anime: ').lower()
                animes = self.urlDAO.listar_nome(nome)
                num = 1
                for anime in animes:
                    print(str(num) + ' - ' + str(anime.nome))
                    num += 1
                opcao = input('Digite o número do anime: ')

                for x in range(1, len(animes) + 1):
                    x -= 1
                    for anime in animes:

                        if opcao == str(x + 1):
                            anime.abrir()

            if opcao1 == '13':
                nome = input('Digite o nome do evento: ')
                tema = input('Digite o tema do evento: ')
                local = input('Digite o local do evento: ')
                data = input('Digite a data do evento (DD/MM/AAAA): ')
                hora_ini = input(
                    'Digite o horário de início do evento (HH:MM): ')
                hora_fim = input('Digite o horário de fim do evento (HH:MM): ')
                try:
                    self.criar_evento(nome, tema, local, data, hora_ini,
                                      hora_fim)

                except ValueError:
                    print(
                        'Não foi possível cadastrar usuário. Erro: Data inserida de forma incorreta'
                    )

            if opcao1 == '14':
                eventos = self.eventoDAO.listar()
                for e in eventos:
                    print('Nome:', e.nome)
                    print('Tema:', e.tema)
                    print('Local:', e.local)
                    print('Data:', e.data)
                    print('Horário de início:', e.hora_ini)
                    print('Horário de fim:', e.hora_fim)
                    print(' ')

            if opcao1 == '15':
                eventos = self.eventoDAO.listar_passados()
                for e in eventos:
                    print('Nome:', e.nome)
                    print('Tema:', e.tema)
                    print('Local:', e.local)
                    print('Data:', e.data)
                    print('Horário de início:', e.hora_ini)
                    print('Horário de fim:', e.hora_fim)
                    print(' ')

            if opcao1 == 'x':
                self.menu_inicial()

            print('FEED')
            print('1 - Publicar')
            print('2 - Adicionar amigo')
            print('3 - Buscar email de seu amigo')
            print('4 - Mudar profissão')
            print('5 - Listar minhas informações')
            print('6 - Desfazer amizade')
            print('7 - Listar amigos')
            print('8 - Alterar sua senha')
            print('9 - Excuir conta')
            print('10 - BATE-PAPO')
            print('11 - Adicionar anime com site')
            print('12 - Buscar anime ou site pelo nome')
            print('13 - Criar evento')
            print('14 - Listar eventos futuros')
            print('15 - Listar eventos passados ')
            print('x - Sair')
            opcao1 = input('Digite a opção (feed): ').lower()
        return opcao1
Example #19
0
 def rodaServidor(self):
     cliente1 = Cliente(self.email, self.senha, "bol")
     self.listaUsuarios.append(cliente1.montaConta())
     mensagem1 = Mensagem(cliente1.login, input("Digite o destinatario: "), input("Digite o assunto: "),\
        input("Digite sua mensagem: "))
     self.listaMensagens.append(mensagem1.montaMensagem())
Example #20
0
from servidor import Servidor
from mensagem import Mensagem

s1 = Servidor('gmail')
c1 = Cliente('Yago', '123456', s1)
s1.cadastrarCliente(c1)

s2 = Servidor('hotmail')
c2 = Cliente('Luis', '123424', s2)
s2.cadastrarCliente(c2)

s3= Servidor('outlook')
c3 = Cliente('Thays', '345678', s3)
s3.cadastrarCliente(c3)

m1 = Mensagem('Yago', 'Thays', 'Aula do Menezes', \
             'Thays, hoje a aula vai ser maneira!!!!!')
m2 = Mensagem('Yago', 'Thays', 'teste para ser apagado', \
             'Thays, tem que apagar!!!!!')



c1.enviarMensagem(m1)

'''
s.receberMensagem(m, '123456') #senha correta
print("Primeiro envio: tamanho da lista = ", len(s.getMensagens()))

s.receberMensagem(m, '123') #senha errada
print("Segundo envio: tamanho da lista = ", len(s.getMensagens()))

'''
from cliente import Cliente
from servidor import Servidor
from mensagem import Mensagem

c = Cliente('Yago', '123456', 'gmail')
s = Servidor('gmail')
s.cadastrarCliente(c)
c = Cliente('Thays', '345678', 'gmail')
s.cadastrarCliente(c)
m = Mensagem('Yago', 'Thays', 'Aula do Menezes', \
             'Thays, hoje a aula vai ser maneira!!!!!')
s.receberMensagem(m, '123456')  #senha correta
print("Primeiro envio: tamanho da lista = ", len(s.getMensagens()))

s.receberMensagem(m, '123')  #senha errada
print("Segundo envio: tamanho da lista = ", len(s.getMensagens()))
dns = DNS()
s1 = Servidor('gmail', dns)
s2 = Servidor('hotmail', dns)
s3 = Servidor('yahoo', dns)
dns.cadastrarServidor('gmail', s1)
dns.cadastrarServidor('hotmail', s2)
dns.cadastrarServidor('yahoo', s3)

gabriel = Cliente("Gozales", "burrito", s1)
caio = Cliente("Caio", "zica", s1)
alexandre = Cliente("Alexandre", "thegreat", s2)
cachorrao = Cliente("cachorrao", "lenis", s2)
marcao = Cliente("berranteiro", "tbt", s3)
miguel = Cliente("Vinicius", "PAIton", s3)

m1 = Mensagem('gabriel', 'alexandre', 'hotmail.com', "teste", "teste")
m2 = Mensagem('gabriel', 'cachorrao', 'hotmail.com', "Saaalve",
              "Saalve cachorro!")
m3 = Mensagem('alexandre', 'marcao', 'yahoo.com.br', "Sdds",
              "Liberdade vai canta")

m4 = Mensagem('cachorrao', 'miguel', 'yahoo.com', "Aula LP 2",
              "Ex dificil pra p***")
m5 = Mensagem('miguel', 'alexandre', 'hotmail.com', "Aula LP 2",
              "Ex dificil pra p***")
m6 = Mensagem('miguel', 'gabriel', 'gmail.com', "Aula LP 2",
              "Ex dificil pra p***")
m7 = Mensagem('gabriel', 'caio', 'gmail.com', "Aula LP 2",
              "Ex dificil pra p***")
m8 = Mensagem('caio', 'miguel', 'yahoo.com.br', "Aula LP 2",
              "Ex dificil pra p***")
Example #23
0
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                mostrar_tela_jogo = False

        if event.type == pygame.MOUSEBUTTONDOWN:
            if pygame.mouse.get_pressed()[0]:
                resultado = tela_do_jogador.clicou_em_alguma_das_minhas_casa(
                    pygame.mouse.get_pos())
                time.sleep(0.5)
                if resultado:
                    novos_valores_pecas_tabuleiro = (
                        tela_do_jogador.pegar_os_valores_das_casas_e_kallah())

                    mensagem_movimentacao = Mensagem(
                        tipo=TipoPermitidosDeMensagem.movimentacao.value,
                        conteudo=novos_valores_pecas_tabuleiro,
                        remetente=meu_nome_usuario,
                    )

                    cliente.enviar_movimentacao_ao_servidor(
                        mensagem_movimentacao)
                    resultado = False
                    continue
        try:
            terminou = tela_do_jogador.verficar_se_alguem_ganhou()
            if terminou:
                mostrar_tela_jogo = False
            tela_do_jogador.desenhar_elementos_na_tela()
            tela_do_jogador.mostrar_tela_do_jogador()
        except KeyboardInterrupt:
            cliente.encerrar_conexao_servidor()