Ejemplo n.º 1
0
class Jogo(object):
    def __init__(self):
        #criar area principal do jogo
        self.root = Tk()
        self.root.geometry('%ix%i' % (LARGURA, ALTURA))
        self.root.resizable(False, False)
        self.root.title('Primeiro Jogo')

        #frame para conter o canvas
        self.frame = Frame(bg="blue")
        self.frame.pack()

        #codigo de craição do canvas
        self.canvas = Canvas(self.frame,
                             bg="black",
                             width=CANVAS_L,
                             height=CANVAS_A,
                             cursor='target')
        foto = PhotoImage(file="fundo/fundo.gif")
        self.canvas.create_image(CANVAS_L / 2, CANVAS_A / 2, image=foto)
        self.canvas.pack()

        #criando objetos dentro do canvas
        self.comecar = Button(self.root, text='INICIAR', command=self.comeca)
        self.comecar.focus_force()
        self.comecar.pack()

        #iniciar jogo com enter
        self.comecar.bind('<Return>', self.comeca)
        self.carregaImagens()
        self.novoJogo()

        self.root.mainloop()

    def carregaImagens(self):

        self.spritesheet = []
        for i in range(1, 9):
            self.spritesheet.append(PhotoImage(file="fundo/%.2i.gif" % i))

        self.number_of_sprite = 0
        self.limite = len(self.spritesheet) - 1

    def novoJogo(self):
        #criação dos elementos do jogo
        self.player = Retangulo(largura=100,
                                altura=20,
                                cor='white',
                                pos=(LARGURA // 2 + 360, 380),
                                vel=(15, 15),
                                tag='player')
        self.player.desenhar(self.canvas)
        #movendo o player com o mouse
        self.canvas.bind('<Motion>', self.move_player)

        #criar a bolinha do jogo
        self.bola = Bola(raio=30, cor='red', pos=(100, 200), vel=(3, 3))

        #lista dos retangulos
        self.r = []
        l, c, e = 5, 8, 2  #linhas, colunas e espaçacamentos
        b, h, y0 = 48, 20, 50  #base, altura e posição inicial
        for i in range(l):
            cor = random.choice([
                'black', 'orange', 'white', 'lightgray', 'yellow', 'green',
                'purple'
            ])
            for j in range(c):
                r = Retangulo(b, h, cor,
                              (b * j + (j + 1) * e, i * h + (i + 1) * e + y0),
                              (0, 0), 'rect')
                self.r.append(r)
        self.canvas.create_text(CANVAS_L / 2,
                                CANVAS_A / 2,
                                text='Bem Vindos!',
                                fill='white',
                                font='Verdana, 12')

        #mudar o estado para jogando
        self.jogando = True

    def comeca(self):
        #iniciar o jogo
        self.jogar()

    def jogar(self):
        #vai ser executado enquanto o jogador estiver jogando
        if self.jogando:
            self.update()
            self.desenhar()

            if len(self.r) == 0:
                self.jogando = False
                self.msg = "VOCÊ GANHOU!!"
            if self.bola.y > CANVAS_A:
                self.jogando = False
                self.msg = "VOCÊ PERDEU!!"

            self.root.after(10, self.jogar)
        else:
            self.acabou(self.msg)

    def update(self):
        #movimento da bola
        self.bola.update(self)

        self.number_of_sprite += 1
        if self.number_of_sprite > self.limite:
            self.number_of_sprite = 0

    def recomeça(self):
        self.novoJogo()
        self.comecar['text'] = 'INICIAR'
        self.jogar()

    def acabou(self, msg):
        self.canvas.delete(ALL)
        self.canvas.create_text(CANVAS_L / 2,
                                CANVAS_A / 2,
                                text=msg,
                                fill='white')
        self.comecar['text'] = 'Reiniciar'
        self.comecar['command'] = self.recomeça

    def desenhar(self):
        #metodo para redesenhar a tela do jogo
        #primeiro apagamos tudo que ha no canvas
        self.canvas.delete(ALL)

        #inserir imagens no canvas
        self.canvas.create_image((CANVAS_L / 2, CANVAS_A / 2),
                                 image=self.spritesheet[self.number_of_sprite])

        #e o player
        self.player.desenhar(self.canvas)

        #e por fim todos os retangulos
        for r in self.r:
            r.desenhar(self.canvas)

        #depois dsenhamos a bola
        self.bola.desenhar(self.canvas)

    def verificarColisao(self):
        #criar uma bouding box para a bola
        coord = self.canvas.bbox('bola')

        #pegar informações dos objetos que colidem com a bola
        colisoes = self.canvas.find_overlapping(*coord)

        #se o numero de colisoes é diferente de 0
        if len(colisoes) != 0:
            #verificar se o id do objeto colidido é diferente do id do objeto do player
            if colisoes[0] != self.player:
                #vamos colocar para que a colisao ocorre com o objeto mais proximo do topo esquerdo
                m_p = self.canvas.find_closest(coord[0], coord[1])
                #idenfificar com qual retangulo ocorreu a colisao
                for i in self.r:
                    #tendo encontrado um retangulo
                    if i == m_p[0]:
                        self.r.remove(i)  #removomento o retangulo do jogo
                        self.canvas.delete(i)
                        #inverter o sentido da valocidade da bola
                        self.b_vy *= -1
                        return

    def move_player(self, event):
        #movimento do meu player - rebatedor
        if event.x > 0 and event.x < CANVAS_L - self.player.b:
            self.player.x = event.x
Ejemplo n.º 2
0
class Jogo(object):
    def __init__(self):

        #Criar área principal do jogo

        self.root = Tk()
        self.root.geometry('%ix%i' % (LARGURA, ALTURA))
        self.root.resizable(False, False)
        self.root.title('SPACE GAME')
        self.root['bg'] = '#05F1F5'
        self.root.wm_iconbitmap('icone.ico')

        #Frame para conter o canvas

        self.frame = Frame(bg="blue")
        self.frame.pack()

        #Código de criação do canvas
        self.canvas = Canvas(self.frame,
                             bg="black",
                             width=CANVAS_L,
                             height=CANVAS_A,
                             cursor='hand2')
        foto = PhotoImage(file="fundo/fundo.gif")
        self.canvas.create_image(CANVAS_L / 2, CANVAS_A / 2, image=foto)
        self.canvas.pack()

        #Criando objetos dentro do canvas
        #self.canvas.create_line(10, 10, 400, 400, fill='white')
        #self.canvas.create_polygon((100, 200), (150, 250), (250, 250), (300, 200), (300, 100), (250, 50),(150, 50), (150, 50), (100, 100), fill = 'white')

        self.comecar = Button(self.root,
                              text='START',
                              bg='white',
                              command=self.começa)
        self.comecar.focus_force()
        self.comecar.pack()

        self.comecar.bind('<Return>', self.começa)
        self.carregaImagens()
        self.novoJogo()

        self.root.mainloop()

    def carregaImagens(self):

        self.spritesheet = []
        for i in range(1, 9):

            self.spritesheet.append(PhotoImage(file="fundo/%.2i.gif" % i))

        self.number_of_sprite = 0
        self.limite = len(self.spritesheet) - 1

    def novoJogo(self):
        #Criação dos elementos do jogo
        self.player = Retangulo(largura=100,
                                altura=20,
                                cor='white',
                                pos=(LARGURA // 2 + 360, 380),
                                vel=(15, 15),
                                tag='player')
        self.player.desenhar(self.canvas)
        self.canvas.bind('<Motion>', self.move_player)

        #Criar a bolinha do jogo
        self.bola = Bola(raio=30, cor='gold', pos=(100, 200), vel=(3, 3))

        #lista dos retangulos
        self.r = []
        l, c, e = 5, 8, 2  #linhas, colunas e espaçamentos
        b, h, y0 = 48, 20, 50  #base, altura e posição inicial

        for i in range(l):
            cor = random.choice([
                'yellow', 'orange', 'gold', 'silver', 'light blue', 'green',
                'blue', 'purple', 'red', 'black', 'brown'
            ])
            for j in range(c):
                r = Retangulo(b, h, cor,
                              (b * j + (j + 1) * e, i * h + (i + 1) * e + y0),
                              (0, 0), 'rect')
                self.r.append(r)
        self.canvas.create_text(CANVAS_L // 2,
                                CANVAS_A / 2,
                                text='Welcome!',
                                fill='white',
                                font='Verdana, 12 bold')

        #mudar o estado para jogando
        self.jogando = True

    def começa(self):
        #iniciar o jogo
        self.jogar()

    def jogar(self):
        #Vai ser executando enquanto o jogador estiver jogando
        if self.jogando:
            self.update()
            self.desenhar()
            if len(self.r) == 0:
                self.jogando = False
                self.msg = "YOU WIN!"
            if self.bola.y > CANVAS_A:
                self.jogando = False
                self.msg = "YOU LOSE!"

            self.root.after(10, self.jogar)
        else:
            self.acabou(self.msg)

    def move_player(self, event):
        #Movimentação do player - rebatedor
        if event.x > 0 and event.x < CANVAS_L - self.player.b:
            self.player.x = event.x

    def update(self):
        #movimento da bola
        self.bola.update(self)

        self.number_of_sprite += 1
        if self.number_of_sprite > self.limite:
            self.number_of_sprite = 0

    def recomeça(self):
        self.novoJogo()
        self.comecar['text'] = 'START'
        self.jogar()

    def acabou(self, msg):
        self.canvas.delete(ALL)
        self.canvas.create_text(CANVAS_L / 2,
                                CANVAS_A / 2,
                                text=msg,
                                fill='white',
                                font='Verdana, 18 bold')
        self.comecar['text'] = 'RESTART'
        self.comecar['command'] = self.recomeça

    def desenhar(self):
        '''
        Método para redesenhar a tela do jogo
        '''
        #primeiro apagamos tudo que há no canvas
        self.canvas.delete(ALL)

        #Inserir imagens no canvas
        self.canvas.create_image((CANVAS_L / 2, CANVAS_A / 2),
                                 image=self.spritesheet[self.number_of_sprite])

        #e o player
        self.player.desenhar(self.canvas)

        #E por fim todos os retangulos
        for r in self.r:
            r.desenhar(self.canvas)

            #depois desenhamos a bola
            self.bola.desenhar(self.canvas)

    def verificaColisao(self):
        #Criar uma bouding box para a bola
        coord = self.canvas.bbox('bola')
        #x1, y1, x2, y2

        #Pegar informações dos objetos que colidem com a bola
        colisoes = self.canvas.find_overlapping(*coord)

        #Se o numero de colisões é diferente de 0
        if len(colisoes) != 0:
            #verificar se o id do objeto colidido é difernte do id do objeto do player
            if colisoes[0] != self.player:
                #colocar para que a colisao ocorre com o objeto mais prox do topo esquerdo
                m_p = self.canvas.find_closest(coord[0], coord[1])
                #identificar com qual retangulo ocorreu a colisao
                for r in self.r:
                    #Tendo encontrado um retangulo
                    if r == m_p[0]:
                        self.r.remove(r)  #removendo o retangulo
                        self.canvas.delete(r)
                        #inverter o sentido da velocidade da bola
                        self.b_vy *= -1
                        return
Ejemplo n.º 3
0
class Jogo(object):
    """
    Classe que organiza os elementos do jogo
    """
    def __init__(self):
        #Criamos o conteiner principal do jogo
        self.root = Tk()
        self.root.geometry('%ix%i' % (LARGURA, ALTURA))
        self.root.resizable(False, False)
        self.root.title('Joguinho Besta')
        self.root.bind('<Escape>', sys.exit)

        #E uma frame para conter o canvas
        self.frame = Frame(bg="black")
        self.frame.pack()

        #Criamos a tela do jogo
        self.canvas = Canvas(self.frame,
                             bg="black",
                             width=CANVAS_L,
                             height=CANVAS_A)
        self.canvas.pack()

        #E colocamos um botã para começar o jogo
        self.começar = Button(self.root, text='START', command=self.começa)
        self.começar.focus_force()
        self.começar.pack()

        #Bind com a tecla enter
        #self.começar.bind('<Return>', self.começa)

        #Carrega o spritesheet
        self.CarregaImagens()

        self.novoJogo()

        self.root.mainloop()

    def CarregaImagens(self):
        """
        Carrega as imagens de animação no fundo
        """
        self.spritesheet = []
        for i in range(1, 91):
            #gif, pgm, ppm, pbx --> PIL == Pillow (png, jpeg...)
            self.spritesheet.append(
                PhotoImage(file="psico_bg/psico_%.2i.gif" % i))

        self.number_of_sprite = 0
        self.limite = len(self.spritesheet) - 1

    def novoJogo(self):
        """
        Cria os elementos necessário para um novo jogo
        """
        #Criamos a bola que irá se movimentar
        self.bola = Bola(raio=30, cor='red', pos=(100, 200), vel=(300, 300))

        #E o player tambem
        self.player = Retangulo(largura=100,
                                altura=20,
                                cor='green',
                                pos=(LARGURA // 2 + 100, 350),
                                vel=(15, 15),
                                tag='player')
        self.player.desenhar(self.canvas)

        #E adicionamos o evento de movimentação com o uso do teclado para o player
        self.canvas.bind('<Motion>', self.move_player)

        #Lista dos retângulos
        self.r = []

        #E por fim as diversas fileiras de retângulos
        l, c, e = 5, 8, 2  #linhas, colunas e espaçamento
        b, h, y0 = 48, 20, 50  #Base, altura e posição inicial dos retângulos
        for i in range(l):
            cor = random.choice(
                ['green', 'orange', 'white', 'lightgray', 'yellow', 'purple'])
            for j in range(c):
                r = Retangulo(b, h, cor,
                              (b * j + (j + 1) * e, i * h + (i + 1) * e + y0),
                              (0, 0), 'rect')
                self.r.append(r)

        #Mantemos uma variável para mostrar que ainda está rolando um jogo
        self.jogando = True

    def começa(self):
        """
        Inicia o jogo
        """
        if 'win' in sys.platform:
            winsound.PlaySound(
                "som_test.wav", winsound.SND_FILENAME | winsound.SND_ASYNC
                | winsound.SND_NODEFAULT | winsound.SND_LOOP)
        self.jogar()

    def jogar(self):
        """
        Deve ser executado enquanto o jogo estiver rodando
        """
        if self.jogando:
            t0 = time.time()

            self.update()
            self.desenhar()

            if len(self.r) == 0:
                self.jogando = False
                self.msg = 'VENCEU'
            if self.bola.y > CANVAS_A:
                self.jogando = False
                self.msg = 'PERDEU'

            tf = time.time()

            deltaT = tf - t0

            self.root.after(round((DT - deltaT) * 1000), self.jogar)
        else:
            self.acabou(self.msg)

    def move_player(self, event):
        """
        Move o player na tela de acordo com o movimento do mouse
        """
        if event.x > 0 and event.x < CANVAS_L - self.player.b:
            self.player.x = event.x

    def update(self):
        """
        Updatamos as condições do jogo
        """
        self.bola.update(self)

        self.number_of_sprite += 1
        if self.number_of_sprite > self.limite:
            self.number_of_sprite = 0

        #Depois de mover a bola é preciso procurar por colisões
        #self.VerificaColisão()

    def desenhar(self):
        """
        Método para redesenhar a tela do jogo
        """
        #primeiro apagamos tudo que há no canvas
        self.canvas.delete(ALL)

        #Desenhamos o background
        self.canvas.create_image((CANVAS_L / 2, CANVAS_A / 2),
                                 image=self.spritesheet[self.number_of_sprite])

        #e o player
        self.player.desenhar(self.canvas)

        #E por fim todos os retângulos
        for r in self.r:
            r.desenhar(self.canvas)

        #depois desenhamos a bola
        self.bola.desenhar(self.canvas)

    def recomeça(self):
        """
        Recomeça o jogo
        """
        self.novoJogo()
        self.começar['text'] = 'START'
        self.jogar()

    def acabou(self, msg):
        """
        Aparece a msg na tela informando o player se ele ganhou ou perdeu
        """
        self.canvas.delete(ALL)
        self.canvas.create_text(CANVAS_L / 2,
                                CANVAS_A / 2,
                                text=msg,
                                fill='white')
        self.começar['text'] = 'RESTART'
        self.começar['command'] = self.recomeça

    def VerificaColisão(self):
        """
        Verifica se houve alguma colisão entre elementos do jogo
        """
        #Primeiro criamos uma bounding box para a bola
        coord = self.canvas.bbox('bola')
        #x1, y1, x2, y2

        #Depois pegamos a id de todos os objetos que colidem com a bola
        colisoes = self.canvas.find_overlapping(*coord)

        #Se o número de colisões for diferente de zero
        if len(colisoes) != 0:
            #verificamos se o id do objeto é diferente do player
            if colisoes[0] != self.player:
                #Vamos checar a colisão com o objeto mais próximo do topo
                #esquerdo da bola
                m_p = self.canvas.find_closest(coord[0], coord[1])

                #Depois temos que olhar para cada um dos retângulos para identificar
                #com quem a bola colidiu
                for r in self.r:
                    #tendo encontrado o retângulo
                    if r == m_p[0]:
                        #deletamos ele do jogo
                        self.r.remove(r)
                        self.canvas.delete(r)

                        #E invertemos o sentido da velocidade da bola
                        self.b_vy *= -1

                        #Por fim saimos da função
                        return
Ejemplo n.º 4
0
class Jogo(object):
    """
    Classe que organiza os elementos do jogo
    """
    def __init__(self):
        #Criamos o conteiner principal do jogo
        self.root = Tk()
        self.root.geometry('%ix%i' % (LARGURA, ALTURA))
        self.root.resizable(False, False)
        self.root.title('Joguinho Besta')

        #E uma frame para conter o canvas
        self.frame = Frame(bg="black")
        self.frame.pack()

        #Criamos a tela do jogo
        self.canvas = Canvas(self.frame,
                             bg="black",
                             width=CANVAS_L,
                             height=CANVAS_A)
        self.canvas.pack()

        #E colocamos um botã para começar o jogo
        self.começar = Button(self.root, text='START', command=self.começa)
        self.começar.focus_force()
        self.começar.pack()

        #Bind com a tecla enter
        self.começar.bind('<Return>', self.começa)

        self.novoJogo()

        self.root.mainloop()

    def novoJogo(self):
        """
        Cria os elementos necessário para um novo jogo
        """
        #Criamos a bola que irá se movimentar
        self.bola = Bola(raio=30, cor='red', pos=(100, 200), vel=(3, 3))

        #E o player tambem
        self.player = Retangulo(largura=100,
                                altura=20,
                                cor='green',
                                pos=(LARGURA // 2 + 100, 350),
                                vel=(15, 15),
                                tag='player')
        self.player.desenhar(self.canvas)

        #E adicionamos o evento de movimentação com o uso do teclado para o player
        self.canvas.bind('<Motion>', self.move_player)

        #Lista dos retângulos
        self.r = []

        #E por fim as diversas fileiras de retângulos
        l, c, e = 5, 8, 2  #linhas, colunas e espaçamento
        b, h, y0 = 48, 20, 50  #Base, altura e posição inicial dos retângulos
        for i in range(l):
            cor = random.choice(
                ['green', 'orange', 'white', 'lightgray', 'yellow', 'purple'])
            for j in range(c):
                r = Retangulo(b, h, cor,
                              (b * j + (j + 1) * e, i * h + (i + 1) * e + y0),
                              (0, 0), 'rect')
                self.r.append(r)

        #Mantemos uma variável para mostrar que ainda está rolando um jogo
        self.jogando = True

    def começa(self, event):
        """
        Inicia o jogo
        """
        self.jogar()

    def jogar(self):
        """
        Deve ser executado enquanto o jogo estiver rodando
        """
        if self.jogando:
            self.update()
            self.desenhar()

            self.root.after(10, self.jogar)

        else:
            self.acabou(self.msg)

    def move_player(self, event):
        """
        Move o player na tela de acordo com o movimento do mouse
        """
        if event.x > 0 and event.x < CANVAS_L - self.player.b:
            self.player.x = event.x

    def update(self):
        """
        Updatamos as condições do jogo
        """
        self.bola.update(self)

        #Depois de mover a bola é preciso procurar por colisões
        #self.VerificaColisão()

    def desenhar(self):
        """
        Método para redesenhar a tela do jogo
        """
        #primeiro apagamos tudo que há no canvas
        self.canvas.delete(ALL)

        #e o player
        self.player.desenhar(self.canvas)

        #E por fim todos os retângulos
        for r in self.r:
            r.desenhar(self.canvas)

        #depois desenhamos a bola
        self.bola.desenhar(self.canvas)

    def VerificaColisão(self):
        """
        Verifica se houve alguma colisão entre elementos do jogo
        """
        #Primeiro criamos uma bounding box para a bola
        coord = self.canvas.bbox('bola')
        #x1, y1, x2, y2

        #Depois pegamos a id de todos os objetos que colidem com a bola
        colisoes = self.canvas.find_overlapping(*coord)

        #Se o número de colisões for diferente de zero
        if len(colisoes) != 0:
            #verificamos se o id do objeto é diferente do player
            if colisoes[0] != self.player:
                #Vamos checar a colisão com o objeto mais próximo do topo
                #esquerdo da bola
                m_p = self.canvas.find_closest(coord[0], coord[1])

                #Depois temos que olhar para cada um dos retângulos para identificar
                #com quem a bola colidiu
                for r in self.r:
                    #tendo encontrado o retângulo
                    if r == m_p[0]:
                        #deletamos ele do jogo
                        self.r.remove(r)
                        self.canvas.delete(r)

                        #E invertemos o sentido da velocidade da bola
                        self.b_vy *= -1

                        #Por fim saimos da função
                        return
Ejemplo n.º 5
0
class Jogo(object):
    def __init__(self):

      
        self.root = Tk()
        self.root.geometry('%ix%i' %(LARGURA, ALTURA))
        self.root.resizable(False, False)
        self.root.title('Primeiro Jogo')

      
        self.frame = Frame(bg="blue")
        self.frame.pack()

        self.canvas = Canvas(self.frame, bg="blue", width=CANVAS_L, height=CANVAS_A, cursor = 'target')
        self.canvas.pack()

        
       
        self.comecar = Button(self.root, text='INCIAR', command=self.começa)
        self.comecar.focus_force()
        self.comecar.pack()

        self.comecar.bind('<Return>', self.começa)
        self.novoJogo()
          
        self.root.mainloop()


    def novoJogo(self):
        
        self.player = Retangulo(largura = 100, altura = 20, cor = 'white', pos = (LARGURA//2 + 360, 380), vel = (15, 15), tag = 'player')
        self.player.desenhar(self.canvas)
        self.canvas.bind('<Motion>', self.move_player)
        
        self.bola = Bola(raio = 30, cor = 'red', pos = (100, 200), vel = (3, 3))
        
        
        
        self.r = []
        l, c, e = 5, 8, 2
        b, h, y0 = 48, 20, 50

        for i in range(l):
            cor = random.choice(['black', 'orange', 'white', 'lightgray', 'yellow', 'green', 'purple'])
            for j in range(c):
                r = Retangulo(b, h, cor, (b*j+(j+1)*e, i*h+(i+1)*e + y0), (0, 0), 'rect')
                self.r.append(r)
        self.canvas.create_text(CANVAS_L/2, CANVAS_A/2, text = 'Bem Vindos!!', fill='white', font='Verdana, 12')

        self.jogando = True

    def começa(self):
        self.jogar()

    def jogar(self):
        
        if self.jogando:
            self.update()
            self.desenhar()
            
            if len(self.r) == 0:
                self.jogando = False
                self.msg = "VOCÊ GANHOU!!"
            if self.bola.y > CANVAS_A:
                self.jogando = False
                self.msg = "VOCÊ PERDEU!!"
                
            self.root.after(10, self.jogar)
        else:
            self.acabou(self.msg)


    def move_player(self, event):

        if event.x > 0 and event.x < CANVAS_L - self.player.b:
            self.player.x = event.x

    def update(self):
     
        self.bola.update(self)

        
    def recomeça(self):
        self.novoJogo()
        self.comecar['text'] = 'INICIAR'
        self.jogar()


    def acabou(self, msg):
        self.canvas.delete(ALL)
        self.canvas.create_text(CANVAS_L/2, CANVAS_A/2, text= msg, fill='white')
        self.comecar['text'] = 'Reiniciar'
        self.comecar['command'] = self.recomeça


    def desenhar(self):

        self.canvas.delete(ALL)

        self.player.desenhar(self.canvas)
       
        for r in self.r:
            r.desenhar(self.canvas)
 
        self.bola.desenhar(self.canvas)
         
        

    def verificaColisao(self):
       
        coord = self.canvas.bbox('bola')
     

        colisoes = self.canvas.find_overlapping(*coord)

        if len(colisoes) != 0:
            if colisoes[0] != self.player:
            
                m_p = self.canvas.find_closest(coord[0], coord[1])
            
                for r in self.r:
            
                    if r == m_p[0]:
                        self.r.remove(r)   
                        self.canvas.delete(r)
                        self.b_vy *= -1
                        return