class ControleTelaDerrota:
    def __init__(self):
                                        #Back   #Jogar   #Quit    #Contorno
        self.posicao_imagens_derrota = [[0,0],[400,500],[510,500],[400,500]]
        self.teclado=ControleTeclado()

    def controla_derrota(self,opcao):

        self.opcao=opcao
        self.esquerda,self.direita,self.esc,self.espaco=2,3,4,6
        self.jogar,self.quit,self.contorno=1,2,3
        self.largura,self.altura=0,1
        self.velocidade_contorno_largura=110
        self.teclado.captura_evento()

        if self.teclado.teclas[self.direita] and (self.posicao_imagens_derrota[self.contorno][self.altura] == self.posicao_imagens_derrota[self.jogar][self.altura] and self.posicao_imagens_derrota[self.contorno][self.largura] < self.posicao_imagens_derrota[self.quit][self.largura]):
            self.posicao_imagens_derrota[self.contorno][self.largura]+=self.velocidade_contorno_largura

        elif self.teclado.teclas[self.esquerda] and (self.posicao_imagens_derrota[self.contorno][self.altura] == self.posicao_imagens_derrota[self.jogar][self.altura] and self.posicao_imagens_derrota[self.contorno][self.largura] > self.posicao_imagens_derrota[self.jogar][self.largura]):
            self.posicao_imagens_derrota[self.contorno][self.largura]-=self.velocidade_contorno_largura

        elif self.teclado.teclas[self.espaco]:
            if self.posicao_imagens_derrota[self.contorno][self.altura]==self.posicao_imagens_derrota[self.jogar][self.altura] and self.posicao_imagens_derrota[self.contorno][self.largura]==self.posicao_imagens_derrota[self.jogar][self.largura]:
                self.opcao=3
                return self.opcao

            elif self.posicao_imagens_derrota[self.contorno][self.altura]==self.posicao_imagens_derrota[self.quit][self.altura] and self.posicao_imagens_derrota[self.contorno][self.largura]==self.posicao_imagens_derrota[self.quit][self.largura]:
                pygame.quit()
                sys.exit()
Esempio n. 2
0
class ControleTelaMenu:

    def __init__(self):
                                   #Backg #Jogar   #Record  #Credito   #Sair    #Cursor
        self.posicao_imagens_menu=[(0,0),(230,150),(230,250),(230,350),(230,450),[90,150]] # Lista com as posicoes dos botoes
        self.teclado=ControleTeclado()

    def controla_menu(self,opcao):
        self.opcao=opcao
        self.teclado.captura_evento()

        self.cima,self.baixo,self.esquerda,self.direita,self.esc,self.espaco=0,1,2,3,4,6
        self.background,self.jogar,self.record,self.creditos,self.sair,self.cursor=0,1,2,3,4,5
        self.altura=1
        self.velocidade_altura=100

        if self.teclado.teclas[self.cima] and self.posicao_imagens_menu[self.cursor][self.altura] > self.posicao_imagens_menu[self.jogar][self.altura]: # se a tecla up for pressionada e a posicao do cursor for maior que a altura do primeiro icone (no caso o botao jogar)
            self.posicao_imagens_menu[self.cursor][self.altura]-=self.velocidade_altura # a posicao do cursor decrementada em uma quantidade (no caso 100 unidades)

        if self.teclado.teclas[self.baixo] and self.posicao_imagens_menu[self.cursor][self.altura] < self.posicao_imagens_menu[self.sair][self.altura]: # se a tecla down for pressionada e a posicao do cursor for menor que a altura do ultimo icone (no caso o botao sair)
            self.posicao_imagens_menu[self.cursor][self.altura]+=self.velocidade_altura # a posicao do cursor e incrementada em uma quantidade (no caso 100 unidades)

        if self.teclado.teclas[self.espaco]: # se a tecla Space for pressionada
            if self.posicao_imagens_menu[self.cursor][self.altura]==self.posicao_imagens_menu[self.jogar][self.altura]: # se a posicao altura do cursor for a mesma que o botao jogar
                self.opcao=4
                return self.opcao

            elif self.posicao_imagens_menu[self.cursor][self.altura]==self.posicao_imagens_menu[self.record][self.altura]: # se a posicao altura do cursor for a mesma que o botao record
                self.opcao=7
                return self.opcao


            elif self.posicao_imagens_menu[self.cursor][self.altura]==self.posicao_imagens_menu[self.creditos][self.altura]: # se a posicao altura do cursor for a mesma que o botao creditos
                self.opcao=6
                return self.opcao

            elif self.posicao_imagens_menu[self.cursor][self.altura]==self.posicao_imagens_menu[self.sair][self.altura]: # se a posicao altura do cursor for a mesma que o botao sair
                pygame.quit()
                sys.exit()

        if self.teclado.teclas[self.esc]: # se a tecla pressionada for ESC
            pygame.quit()
            sys.exit()
class ControleTelaNivel:
    def __init__(self):
                     #Backg  #Facil   #Medio   #Dificil    #Voltar  #Cursor
        self.posicao_imagens_nivel=[(0,0),(230,150),(230,250),(230,350),(230,450),[90,150]]
        self.teclado=ControleTeclado()

    def controle_tela_nivel(self,opcao):
        self.opcao=opcao
        self.teclado.captura_evento()
        self.cima,self.baixo,self.esc,self.espaco=0,1,4,6
        self.background,self.facil,self.medio,self.dificil,self.voltar,self.cursor=0,1,2,3,4,5
        self.altura=1
        self.velocidade_altura=100

        if self.teclado.teclas[self.cima]:
            if self.posicao_imagens_nivel[self.cursor][self.altura] > self.posicao_imagens_nivel[self.facil][self.altura]:
                self.posicao_imagens_nivel[self.cursor][self.altura]-=self.velocidade_altura

        elif self.teclado.teclas[self.baixo]:
            if self.posicao_imagens_nivel[self.cursor][self.altura] < self.posicao_imagens_nivel[self.voltar][self.altura]:
                self.posicao_imagens_nivel[self.cursor][self.altura]+=self.velocidade_altura

        elif self.teclado.teclas[self.espaco]:
            if self.posicao_imagens_nivel[self.cursor][self.altura]==self.posicao_imagens_nivel[self.facil][self.altura]:
                self.opcao=9
                return self.opcao

            elif self.posicao_imagens_nivel[self.cursor][self.altura]==self.posicao_imagens_nivel[self.medio][self.altura]:
                self.opcao=10
                return self.opcao

            elif self.posicao_imagens_nivel[self.cursor][self.altura]==self.posicao_imagens_nivel[self.dificil][self.altura]:
                self.opcao=11
                return self.opcao

            elif self.posicao_imagens_nivel[self.cursor][self.altura]==self.posicao_imagens_nivel[self.voltar][self.altura]:
                self.opcao=3
                return self.opcao
class ControleLogin:

    def __init__(self):

        self.tela_login=CriarTelaLogin()
        self.teclado=ControleTeclado()
        self.apl_pessoa=AplGerenciarPessoa()
                                  #Backg  #Login    #Senha   #Confirmar #Limpar  #Cadastrar #Campo1 #Campo2  #Contorno
        self.posicao_imagens_login=[(0,0),(50,150),(50,250),(250,350),(360,350),(470,350),(200,150),(200,250),[50,150]] # Lista com as posicoes dos botoes
        self.erro=False

    def controla_imagens_login(self,janela,lista_login_senha,opcao):

        self.opcao=opcao

        self.teclado.captura_evento()
        background,login,senha,confirmar,limpar,cadastrar,campo1,campo2,contorno=0,1,2,3,4,5,6,7,8
        self.altura=1
        self.largura=0
        velocidade_contorno_altura=100
        velocidade_contorno_largura=110
        self.cima,self.baixo,self.esquerda,self.direita,self.esc,self.espaco,self.letras=0,1,2,3,4,6,7


        if self.teclado.teclas[self.cima] and self.posicao_imagens_login[contorno][self.altura] > self.posicao_imagens_login[login][self.altura] and self.posicao_imagens_login[contorno][self.altura] < self.posicao_imagens_login[confirmar][self.altura]:
            self.posicao_imagens_login[contorno][self.altura]-=velocidade_contorno_altura

        elif self.teclado.teclas[self.baixo] and self.posicao_imagens_login[contorno][self.altura] < self.posicao_imagens_login[senha][self.altura]:
            self.posicao_imagens_login[contorno][self.altura]+=velocidade_contorno_altura

        elif self.teclado.teclas[self.baixo] and self.posicao_imagens_login[contorno][self.altura] == self.posicao_imagens_login[senha][self.altura]:
            self.posicao_imagens_login[contorno][self.altura]= self.posicao_imagens_login[confirmar][self.altura]
            self.posicao_imagens_login[contorno][self.largura]= self.posicao_imagens_login[confirmar][self.largura]

        elif self.teclado.teclas[self.cima] and self.posicao_imagens_login[contorno][self.altura] == self.posicao_imagens_login[confirmar][self.altura]:
            self.posicao_imagens_login[contorno][self.altura]= self.posicao_imagens_login[senha][self.altura]
            self.posicao_imagens_login[contorno][self.largura]= self.posicao_imagens_login[senha][self.largura]

        elif self.teclado.teclas[self.direita] and (self.posicao_imagens_login[contorno][self.altura] == self.posicao_imagens_login[confirmar][self.altura] and self.posicao_imagens_login[contorno][self.largura] < self.posicao_imagens_login[cadastrar][self.largura]):
            self.posicao_imagens_login[contorno][self.largura]+=velocidade_contorno_largura

        elif self.teclado.teclas[self.esquerda] and (self.posicao_imagens_login[contorno][self.altura] == self.posicao_imagens_login[confirmar][self.altura] and self.posicao_imagens_login[contorno][self.largura] > self.posicao_imagens_login[confirmar][self.largura]):
            self.posicao_imagens_login[contorno][self.largura]-=velocidade_contorno_largura

        pessoa_logada=self.controle_se_loga(janela,lista_login_senha)
        return pessoa_logada

    def controle_se_loga(self,janela,lista_login_senha):


        self.teclado.captura_evento()
        self.loginl,self.senhal=0,1
        self.lista_login=lista_login_senha
        background,login,senha,confirmar,limpar,cadastrar,campo1,campo2,contorno=0,1,2,3,4,5,6,7,8

        self.tela_login.imprime_tela_login(janela,self.posicao_imagens_login,lista_login_senha,self.erro)

        if self.teclado.teclas[self.letras] != "":

            if self.posicao_imagens_login[contorno][self.altura] == self.posicao_imagens_login[login][self.altura]:
                if self.teclado.teclas[self.letras] == "\x08": # \x08 e a tecla backspace (apagar)
                    self.tamanho=len(self.lista_login[self.loginl])
                    self.palavra=self.lista_login[self.loginl]
                    self.lista_login[self.loginl]=self.palavra[:self.tamanho-1]
                else:
                    self.lista_login[self.loginl]+=self.teclado.teclas[self.letras]
            elif self.posicao_imagens_login[contorno][self.altura] == self.posicao_imagens_login[senha][self.altura]:
                if self.teclado.teclas[self.letras] == "\x08":
                    self.tamanho=len(self.lista_login[self.senhal])
                    self.palavra=self.lista_login[self.senhal]
                    self.lista_login[self.senhal]=self.palavra[:self.tamanho-1]
                else:
                    self.lista_login[self.senhal]+=self.teclado.teclas[self.letras]

        if self.teclado.teclas[self.espaco]:
            if self.posicao_imagens_login[contorno][self.altura]==self.posicao_imagens_login[confirmar][self.altura] and self.posicao_imagens_login[contorno][self.largura]==self.posicao_imagens_login[confirmar][self.largura]:
                self.pessoa_logada=self.apl_pessoa.login_pessoa(self.lista_login)
                if self.pessoa_logada==None:
                    self.erro=True
                else:
                    self.opcao=3
                    return self.pessoa_logada #(Nome,login,senha,data_nascimento,email)

            if self.posicao_imagens_login[contorno][self.altura]==self.posicao_imagens_login[limpar][self.altura] and self.posicao_imagens_login[contorno][self.largura]==self.posicao_imagens_login[limpar][self.largura]:
                self.lista_login[self.loginl],self.lista_login[self.senhal]="",""
                return self.lista_login

            if self.posicao_imagens_login[contorno][self.altura]==self.posicao_imagens_login[cadastrar][self.altura] and self.posicao_imagens_login[contorno][self.largura]==self.posicao_imagens_login[cadastrar][self.largura]:
                self.opcao=2
                return self.opcao
        if self.teclado.teclas[self.esc]:
            pygame.quit()
            sys.exit()
class ControleCadastro:
    def __init__(self):
        # Backg #Nome    #Login   #Senha   #Email  #DtNasc  #Confirmar #Limpar  #Voltar   #Campo1   #Campo2    #Campo3   #Campo4  #Campo5   #Contorno
        self.posicao_imagens_cadastro = [
            (0, 0),
            (50, 150),
            (50, 200),
            (50, 250),
            (50, 300),
            (50, 350),
            (250, 450),
            (360, 450),
            (470, 450),
            (200, 150),
            (200, 200),
            (200, 250),
            (200, 300),
            (200, 350),
            [50, 150],
        ]  # Lista com as posicoes dos botoes
        self.teclado = ControleTeclado()
        self.aplGerenciarPessoa = AplGerenciarPessoa()
        self.erro = 3

    def controla_imagens_cadastro(self, opcao):

        self.opcao = opcao

        self.teclado.captura_evento()

        background, nome, login, senha, email, dataNascimento, confirmar, limpar, voltar, campo1, campo2, campo3, campo4, campo5, self.contorno = (
            0,
            1,
            2,
            3,
            4,
            5,
            6,
            7,
            8,
            9,
            10,
            11,
            12,
            13,
            14,
        )
        self.altura = 1
        self.largura = 0
        self.velocidade_contorno_altura = 50
        self.velocidade_contorno_largura = 110
        self.cima, self.baixo, self.esquerda, self.direita, self.esc, self.espaco, self.letras = 0, 1, 2, 3, 4, 6, 7

        if (
            self.teclado.teclas[self.cima]
            and self.posicao_imagens_cadastro[self.contorno][self.altura]
            > self.posicao_imagens_cadastro[nome][self.altura]
            and self.posicao_imagens_cadastro[self.contorno][self.altura]
            < self.posicao_imagens_cadastro[confirmar][self.altura]
        ):
            self.posicao_imagens_cadastro[self.contorno][self.altura] -= self.velocidade_contorno_altura

        elif (
            self.teclado.teclas[self.baixo]
            and self.posicao_imagens_cadastro[self.contorno][self.altura]
            < self.posicao_imagens_cadastro[dataNascimento][self.altura]
        ):
            self.posicao_imagens_cadastro[self.contorno][self.altura] += self.velocidade_contorno_altura

        elif (
            self.teclado.teclas[self.baixo]
            and self.posicao_imagens_cadastro[self.contorno][self.altura]
            == self.posicao_imagens_cadastro[dataNascimento][self.altura]
        ):
            self.posicao_imagens_cadastro[self.contorno][self.altura] = self.posicao_imagens_cadastro[confirmar][
                self.altura
            ]
            self.posicao_imagens_cadastro[self.contorno][self.largura] = self.posicao_imagens_cadastro[confirmar][
                self.largura
            ]

        elif (
            self.teclado.teclas[self.cima]
            and self.posicao_imagens_cadastro[self.contorno][self.altura]
            == self.posicao_imagens_cadastro[confirmar][self.altura]
        ):
            self.posicao_imagens_cadastro[self.contorno][self.altura] = self.posicao_imagens_cadastro[dataNascimento][
                self.altura
            ]
            self.posicao_imagens_cadastro[self.contorno][self.largura] = self.posicao_imagens_cadastro[dataNascimento][
                self.largura
            ]

        elif self.teclado.teclas[self.direita] and (
            self.posicao_imagens_cadastro[self.contorno][self.altura]
            == self.posicao_imagens_cadastro[confirmar][self.altura]
            and self.posicao_imagens_cadastro[self.contorno][self.largura]
            < self.posicao_imagens_cadastro[voltar][self.largura]
        ):
            self.posicao_imagens_cadastro[self.contorno][self.largura] += self.velocidade_contorno_largura

        elif self.teclado.teclas[self.esquerda] and (
            self.posicao_imagens_cadastro[self.contorno][self.altura]
            == self.posicao_imagens_cadastro[confirmar][self.altura]
            and self.posicao_imagens_cadastro[self.contorno][self.largura]
            > self.posicao_imagens_cadastro[confirmar][self.largura]
        ):
            self.posicao_imagens_cadastro[self.contorno][self.largura] -= self.velocidade_contorno_largura

    def controla_se_cadastra(self, listaCadastral):
        self.teclado.captura_evento()
        self.nomel, self.loginl, self.senhal, self.emaill, self.dataNascimentol = 0, 1, 2, 3, 4
        self.listaCadastral = listaCadastral
        self.background, self.nome, self.login, self.senha, self.email, self.dataNascimento, self.confirmar, self.limpar, self.voltar, self.campo1, self.campo2, self.campo3, self.campo4, self.campo5, self.contorno = (
            0,
            1,
            2,
            3,
            4,
            5,
            6,
            7,
            8,
            9,
            10,
            11,
            12,
            13,
            14,
        )

        if self.teclado.teclas[self.letras] != "":
            if (
                self.posicao_imagens_cadastro[self.contorno][self.altura]
                == self.posicao_imagens_cadastro[self.nome][self.altura]
            ):
                if self.teclado.teclas[self.letras] == "\x08":
                    self.tamanho = len(self.listaCadastral[self.nomel])
                    self.palavra = self.listaCadastral[self.nomel]
                    self.listaCadastral[self.nomel] = self.palavra[: self.tamanho - 1]
                else:
                    self.listaCadastral[self.nomel] += self.teclado.teclas[self.letras]
                return self.listaCadastral
            elif (
                self.posicao_imagens_cadastro[self.contorno][self.altura]
                == self.posicao_imagens_cadastro[self.login][self.altura]
            ):
                if self.teclado.teclas[self.letras] == "\x08":
                    self.tamanho = len(self.listaCadastral[self.loginl])
                    self.palavra = self.listaCadastral[self.loginl]
                    self.listaCadastral[self.loginl] = self.palavra[: self.tamanho - 1]
                else:
                    self.listaCadastral[self.loginl] += self.teclado.teclas[self.letras]
                return self.listaCadastral
            elif (
                self.posicao_imagens_cadastro[self.contorno][self.altura]
                == self.posicao_imagens_cadastro[self.senha][self.altura]
            ):
                if self.teclado.teclas[self.letras] == "\x08":
                    self.tamanho = len(self.listaCadastral[self.senhal])
                    self.palavra = self.listaCadastral[self.senhal]
                    self.listaCadastral[self.senhal] = self.palavra[: self.tamanho - 1]
                else:
                    self.listaCadastral[self.senhal] += self.teclado.teclas[self.letras]
                return self.listaCadastral
            elif (
                self.posicao_imagens_cadastro[self.contorno][self.altura]
                == self.posicao_imagens_cadastro[self.email][self.altura]
            ):
                if self.teclado.teclas[self.letras] == "\x08":
                    self.tamanho = len(self.listaCadastral[self.emaill])
                    self.palavra = self.listaCadastral[self.emaill]
                    self.listaCadastral[self.emaill] = self.palavra[: self.tamanho - 1]
                else:
                    self.listaCadastral[self.emaill] += self.teclado.teclas[self.letras]
                return self.listaCadastral
            elif (
                self.posicao_imagens_cadastro[self.contorno][self.altura]
                == self.posicao_imagens_cadastro[self.dataNascimento][self.altura]
            ):
                if self.teclado.teclas[self.letras] == "\x08":
                    self.tamanho = len(self.listaCadastral[self.dataNascimentol])
                    self.palavra = self.listaCadastral[self.dataNascimentol]
                    self.listaCadastral[self.dataNascimentol] = self.palavra[: self.tamanho - 1]
                else:
                    self.listaCadastral[self.dataNascimentol] += self.teclado.teclas[self.letras]
                return self.listaCadastral

        if self.teclado.teclas[self.espaco]:
            if (
                self.posicao_imagens_cadastro[self.contorno][self.altura]
                == self.posicao_imagens_cadastro[self.confirmar][self.altura]
                and self.posicao_imagens_cadastro[self.contorno][self.largura]
                == self.posicao_imagens_cadastro[self.confirmar][self.largura]
            ):
                self.problema = self.aplGerenciarPessoa.Cadastrar_pessoa(self.listaCadastral)
                if self.problema == False:
                    self.erro = 0
                else:
                    self.erro = 1

            if (
                self.posicao_imagens_cadastro[self.contorno][self.altura]
                == self.posicao_imagens_cadastro[self.voltar][self.altura]
                and self.posicao_imagens_cadastro[self.contorno][self.largura]
                == self.posicao_imagens_cadastro[self.voltar][self.largura]
            ):
                self.opcao = 1
                self.erro = 3
                return self.opcao

            if (
                self.posicao_imagens_cadastro[self.contorno][self.altura]
                == self.posicao_imagens_cadastro[self.limpar][self.altura]
                and self.posicao_imagens_cadastro[self.contorno][self.largura]
                == self.posicao_imagens_cadastro[self.limpar][self.largura]
            ):
                self.listaCadastral[self.nomel], self.listaCadastral[self.loginl], self.listaCadastral[
                    self.senhal
                ], self.listaCadastral[self.emaill], self.listaCadastral[self.dataNascimentol] = ("", "", "", "", "")
                self.erro = 3
                return self.listaCadastral
class ControleTelaRecordNivel:
    def __init__(self):
        # Backg  #facil  #medio  #dificil #voltar  #TmeuRec #TrecGer #meuRec  #rec1    #rec2    #rec3   #rec4     #rec5   #Contorno
        self.posicao_imagens_record_nivel = [
            (0, 0),
            (50, 30),
            (160, 30),
            (270, 30),
            (380, 30),
            (50, 100),
            (50, 65),
            (50, 165),
            (50, 280),
            (50, 330),
            (50, 380),
            (50, 430),
            (50, 480),
            [50, 30],
        ]  # Lista com as posicoes dos botoes
        self.lista_nome_record = None
        self.teclado = ControleTeclado()
        self.apl_gerencia_record = AplGerenciaRecord()

    def controla_record_nivel(self, opcao):

        self.opcao = opcao
        self.teclado.captura_evento()

        self.esquerda, self.direita, self.esc, self.espaco = 2, 3, 4, 6
        self.background, self.facil, self.medio, self.dificil, self.voltar, self.contorno = 0, 1, 2, 3, 4, 13
        self.largura = 0
        self.velocidade_largura = 110

        if (
            self.teclado.teclas[self.esquerda]
            and self.posicao_imagens_record_nivel[self.contorno][self.largura]
            > self.posicao_imagens_record_nivel[self.facil][self.largura]
        ):
            self.posicao_imagens_record_nivel[self.contorno][self.largura] -= self.velocidade_largura

        if (
            self.teclado.teclas[self.direita]
            and self.posicao_imagens_record_nivel[self.contorno][self.largura]
            < self.posicao_imagens_record_nivel[self.voltar][self.largura]
        ):
            self.posicao_imagens_record_nivel[self.contorno][self.largura] += self.velocidade_largura

        if (
            self.posicao_imagens_record_nivel[self.contorno][self.largura]
            == self.posicao_imagens_record_nivel[self.facil][self.largura]
        ):
            self.lista_nome_record = self.apl_gerencia_record.record("Facil")

        elif (
            self.posicao_imagens_record_nivel[self.contorno][self.largura]
            == self.posicao_imagens_record_nivel[self.medio][self.largura]
        ):
            self.lista_nome_record = self.apl_gerencia_record.record("Medio")

        elif (
            self.posicao_imagens_record_nivel[self.contorno][self.largura]
            == self.posicao_imagens_record_nivel[self.dificil][self.largura]
        ):
            self.lista_nome_record = self.apl_gerencia_record.record("Dificil")

        if self.teclado.teclas[self.espaco]:  # se a tecla Space for pressionada
            if (
                self.posicao_imagens_record_nivel[self.contorno][self.largura]
                == self.posicao_imagens_record_nivel[self.voltar][self.largura]
            ):
                self.opcao = 3
                return self.opcao
Esempio n. 7
0
class ControleTelaJogo:

    def __init__(self):
        self.speed = 10 # quanto de deslocamento o player recebera (simula a velocidade)
        self.speed_janela=10 #quanto de delocamento a janela recebera
        self.teclado=ControleTeclado()
        self.controla_tiro=ControleTiro()
        self.controle_inimigo=ControleInimigo()

    def controlador_player(self,labirinto,opcao): # funcao que controla o deslocamento do player e suas colisoes
        self.teclado.captura_evento()
        self.opcao=opcao

        if self.teclado.teclas[0]: # verifica se a tecla pressionada foi UP
            labirinto.player.direcao=0

            if labirinto.player.rect_player.top<=80 : # verifica se a parte superior do personagem e maior(mais para baixo) que a posicao Y da tela superior
                labirinto.player.rect_player[1]+=self.speed
                for bloco in labirinto.lst_blocos: # se verdadeiro, todos os objetos sao delocados -Y
                    bloco[1]+=self.speed      # demonstrando uma parte mais superior do labirinto
                labirinto.saida[1]+=self.speed
                for grama in labirinto.lst_gramas:
                    grama[1]+=self.speed
                for inimigo in labirinto.lst_inimigos:
                    inimigo.rect_inimigo[1]+=self.speed
                for tiro in labirinto.lst_tiros:
                    tiro[1]+=self.speed
            if labirinto.player.rect_player.top>=0 : # verifica se a parte superior do personagem e maior(mais para baixo) da tela superior
                dy=labirinto.player.rect_player[1] # guarda a posicao atual do personagem
                labirinto.player.rect_player[1]-=self.speed # adiciona speed a posicao do personagem
                for bloco in labirinto.lst_blocos[:]: # verifica para cada bloco
                    if labirinto.player.rect_player.colliderect(bloco): # se o personagem ira colidir, caso receba a nova posicao
                        labirinto.player.rect_player[1]=dy # se o personagem colidir com algum bloco, personagem recebera a posicao guardada
                for inimig in labirinto.lst_inimigos:
                    if labirinto.player.rect_player.colliderect(inimig.rect_inimigo):
                        self.opcao=10

        elif self.teclado.teclas[1]:
            labirinto.player.direcao=1

            if labirinto.player.rect_player.bottom>=550 : # verifica se a parte inferior do personagem e menor(mais para cima) que a posicao Y da tela superior
                labirinto.player.rect_player[1]-=self.speed
                for bloco in labirinto.lst_blocos: # se verdadeiro, todos os objetos sao delocados +Y
                    bloco[1]-=self.speed            # demonstrando uma parte mais inferior do labirinto
                labirinto.saida[1]-=self.speed
                for grama in labirinto.lst_gramas:
                    grama[1]-=self.speed
                for inimigo in labirinto.lst_inimigos:
                    inimigo.rect_inimigo[1]-=self.speed
                for tiro in labirinto.lst_tiros:
                    tiro[1]-=self.speed
            if labirinto.player.rect_player.bottom<=931 :
                dy=labirinto.player.rect_player[1]
                labirinto.player.rect_player[1]+=self.speed
                for bloco in labirinto.lst_blocos[:]:
                    if labirinto.player.rect_player.colliderect(bloco):
                        labirinto.player.rect_player[1]=dy
                for inimig in labirinto.lst_inimigos:
                    if labirinto.player.rect_player.colliderect(inimig.rect_inimigo):
                        self.opcao=10
        elif self.teclado.teclas[2]:
            labirinto.player.direcao=2

            if labirinto.player.rect_player.left<=100 :
                labirinto.player.rect_player[0]+=self.speed
                for bloco in labirinto.lst_blocos:
                    bloco[0]+=self.speed
                labirinto.saida[0]+=self.speed
                for grama in labirinto.lst_gramas:
                    grama[0]+=self.speed
                for inimigo in labirinto.lst_inimigos:
                    inimigo.rect_inimigo[0]+=self.speed
                for tiro in labirinto.lst_tiros:
                    tiro[0]+=self.speed
            if labirinto.player.rect_player.left>=0:
                dy=labirinto.player.rect_player[0]
                labirinto.player.rect_player[0]-=self.speed
                for bloco in labirinto.lst_blocos[:]:
                    if labirinto.player.rect_player.colliderect(bloco):
                        labirinto.player.rect_player[0]=dy
                for inimig in labirinto.lst_inimigos:
                    if labirinto.player.rect_player.colliderect(inimig.rect_inimigo):
                        self.opcao=10

        elif self.teclado.teclas[3]:
            labirinto.player.direcao=3

            if labirinto.player.rect_player.right>=530 : # verifica se a parte inferior do personagem e menor(mais para cima) que a posicao Y da tela superior
                labirinto.player.rect_player[0]-=self.speed
                for bloco in labirinto.lst_blocos: # se verdadeiro, todos os objetos sao delocados +Y
                    bloco[0]-=self.speed            # demonstrando uma parte mais inferior do labirinto
                labirinto.saida[0]-=self.speed
                for grama in labirinto.lst_gramas:
                    grama[0]-=self.speed
                for inimigo in labirinto.lst_inimigos:
                    inimigo.rect_inimigo[0]-=self.speed
                for tiro in labirinto.lst_tiros:
                    tiro[0]-=self.speed
            if labirinto.player.rect_player.right<=931 :
                dy=labirinto.player.rect_player[0]
                labirinto.player.rect_player[0]+=self.speed
                for bloco in labirinto.lst_blocos[:]:
                    if labirinto.player.rect_player.colliderect(bloco):
                        labirinto.player.rect_player[0]=dy
                for inimig in labirinto.lst_inimigos:
                    if labirinto.player.rect_player.colliderect(inimig.rect_inimigo):
                        self.opcao=10

        # se a tecla 5 (tecla C) pressionada, ele cria um tiro e adiciona um tiro na lista de tiros
        # e uma direcao na lista de direcoes
        if self.teclado.teclas[5]:
            labirinto.lst_tiros.append(Tiro().criar_tiro((labirinto.player.rect_player[0],labirinto.player.rect_player[1])))
            labirinto.lst_direcao_tiro.append(labirinto.player.direcao)

        self.controle_inimigo.controla_direcao(labirinto)
        self.controla_tiro.controla_tiro(labirinto)

        if labirinto.player.rect_player.colliderect(labirinto.saida): # se chegar a saida, altera a opcao do loop principal
            self.opcao=9

        tempo=random.randint(10,100)
        return tempo