def test_retangulo(): retangulo_1 = Retangulo(base=10, altura=12) assert (retangulo_1.base) == 10 assert (retangulo_1.altura) == 12 assert (retangulo_1.calcular_area()) == 120 assert (retangulo_1.calcular_perimetro()) == 44
def cria_retangulos(): x = 45 y = 125 for linha in range(6): for ret in range(10): retangulo = Retangulo(x, y, 30, 15) retangulo.troca_cor() retangulos.append(retangulo) x += 31 y += 20 x = 45
def main(instancia): boxes, Lu, Wu, Hu = get_data(instancia) container = [Lu, Wu, Hu] ret = [] for b in boxes: color_i = np.random.rand(1, 3) for i in range(b.get('qtd')): ret.append(Retangulo(b.get('dim'), color=color_i)) now = time() ret, obj = optimize(ret, container) obj = get_obj(ret) print('Time: ' + str(time() - now)) print('Dimensoes: ', Lu, Wu, Hu) print('Função objetivo: ' + str(obj)) x_lim = max(Lu, Wu, obj) y_lim = max(Lu, Wu, obj) z_lim = max(Lu, Wu, obj) visualiser = PolyVisualiser( array_polygons=ret, x_lim=x_lim, y_lim=y_lim, z_lim=z_lim, obj=obj, alpha=1, title=instancia, ) visualiser.animate(no_animation=False) visualiser.scrol() visualiser.show()
class TestExercicio3(unittest.TestCase): def setUp(self): self.retangulo = Retangulo(5, 2) def teste_consultar_lados_do_retangulo(self): self.retangulo.lados |should| equal_to([5, 2]) def teste_alterar_lados_do_retangulo(self): self.retangulo.lados = [6, 3] self.retangulo.lados |should| equal_to([6, 3]) def teste_calcular_area_do_retangulo(self): self.retangulo.calcular_area() |should| equal_to(10) def teste_calcular_perimetro_do_retangulo(self): self.retangulo.calcular_perimetro() |should| equal_to(14)
def novoJogo(self): """ Cria os elementos de um novo jogo """ #criar a bola q irá se movimentar self.bola = Bola(raio=30, cor='red', pos=(100, 200), vel=(3, 3)) #criar player tbm self.player = Retangulo(largura=100, altura=20, cor='green', pos=(LARGURA // 2 + 100, 350), vel=(15, 15), tag='player') #self.player = self.canvas.create_rectangle((CANVAS_L//2, 350), (CANVAS_L//2 + 100, 370), fill = 'green', tag='player') self.player.desenhar(self.canvas) #adicionar o evento de movimentação com o uso do teclado self.canvas.bind('<Motion>', self.move_player) #criar arco dentro da bola #self.canvas.create_arc(p[0], p[1], p[0] + raio, p[1] + raio, fill='orange', start=60, extent = 90, tag='bola') #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 = self.canvas.create_rectangle(b * j + (j + 1) * e, i * h + (i + 1) * e + y0, b * j + (j + 1) * e + b, i * h + (i + 1) * e + y0 + h, fill=cor, tag='rect') self.r.append(r) #self.canvas.create_text(CANVAS_L/2, CANVAS_A/2, text = 'OLA COLEGA!', fill = 'white') #cria bola do jogo self.jogando = True
def retanguloperi(): #definindo a função print("Voce escolheu o Perimetro do Retangulo.") #Situando o usuário try: # utilizamos o try para tratar teclas que não sejam numéricas com excessão do ponto para valores flutuantes base = float(input("Digite a base do retangulo: ") ) #recebendo os valores e setando nas variaveis altura = float(input("Digite a altura do retangulo: ")) meuRetangulo = Retangulo( base, altura) #instanciando a classe e passando os parametros meuperi = meuRetangulo.calculaPerimetroreta( ) # #chamando a classe para receber o resultado print("\nO perimetro do retangulo é {:.2f} cm".format( meuperi)) # apresentando a area do circulo para o usuario escolha() # chamando a função novamente except ValueError: # excessão do try, valor recebido errado, que não seja número print( "Opção inválida, Não utilize letras, virgula ou deixe vazio!\nA entrada deve ser primeiro um número seguido ou não de ponto!" "\nPor Favor, tente novamente." ) # utilizando barra invertida e n quebramos linha escolha() # chamando a função novamente
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 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 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
class TestExercicio8(unittest.TestCase): def setUp(self): self.retangulo = Retangulo(3, 10) def teste_deve_calcular_area(self): self.retangulo.calcular_area() |should| equal_to(30) def teste_deve_calcular_perimetro(self): self.retangulo.calcular_perimetro() |should| equal_to(26) def teste_deve_verificar_se_eh_quadrado(self): self.retangulo.eh_quadrado() |should| equal_to(False)
def main(): figuraComplexa = FiguraComplexa(Quadrado(3), Quadrado(10), Retangulo(2, 7), Retangulo(5, 3)) print(figuraComplexa)
class Test_Retangulo(unittest.TestCase): def setUp(self): self.retangulo = Retangulo(3, 5) def test_alterar_e_consltar_altura(self): self.retangulo.alterar_altura(2) self.retangulo.consultar_altura() | should | equal_to(2) def test_alterar_e_consultar_base(self): self.retangulo.alterar_base(6) self.retangulo.consultar_base() | should | equal_to(6) def test_calcular_area(self): self.retangulo.calcular_area() | should | equal_to(15) def test_nao_aceita_valores_negativos_nem_0(self): (self.retangulo._validar_altura_, 0) | should | throw(ValueError) (self.retangulo._validar_base_, -6) | should | throw(ValueError) def test_calcular_area_e_obter_perimetro(self): self.retangulo.alterar_altura(5) self.retangulo.alterar_base(4) self.retangulo.consultar_altura() | should | equal_to(5) self.retangulo.consultar_base() | should | equal_to(4) self.retangulo.calcular_area() | should | equal_to(20) self.retangulo.obter_perimetro() | should | equal_to(18)
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('Pong') #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, cursor='target') 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.canvas.create_polygon((100, 200), (150, 250), (250, 250), (300, 200), (300, 100), (250, 50), (150, 50), (100, 100), fill = 'white') self.novoJogo() self.root.mainloop() def novoJogo(self): """ Cria os elementos de um novo jogo """ #criar a bola q irá se movimentar self.bola = Bola(raio=30, cor='red', pos=(100, 200), vel=(3, 3)) #criar player tbm self.player = Retangulo(largura=100, altura=20, cor='green', pos=(LARGURA // 2 + 100, 350), vel=(15, 15), tag='player') #self.player = self.canvas.create_rectangle((CANVAS_L//2, 350), (CANVAS_L//2 + 100, 370), fill = 'green', tag='player') self.player.desenhar(self.canvas) #adicionar o evento de movimentação com o uso do teclado self.canvas.bind('<Motion>', self.move_player) #criar arco dentro da bola #self.canvas.create_arc(p[0], p[1], p[0] + raio, p[1] + raio, fill='orange', start=60, extent = 90, tag='bola') #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 = self.canvas.create_rectangle(b * j + (j + 1) * e, i * h + (i + 1) * e + y0, b * j + (j + 1) * e + b, i * h + (i + 1) * e + y0 + h, fill=cor, tag='rect') self.r.append(r) #self.canvas.create_text(CANVAS_L/2, CANVAS_A/2, text = 'OLA COLEGA!', fill = 'white') #cria bola do jogo self.jogando = True def começa(self, event): """ inicia jogo """ self.jogar() def jogar(self): """jogo 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): """update condições de jogo""" self.bola.update(self) #caçar por colisoes #self.VerificaColisao() def desenhar(self): """metodo para redesenhar a tela do jogo""" #self.canvas.delete(self.bola) #self.canvas.delete('bola') #self.canvas.delete('arc') #self.bola = self.canvas.create_oval(self.b_x, self.b_y, self.b_x + 30, self.b_y + 30, fill='red', outline='white', tag='bola') #self.canvas.create_arc(self.b_x, self.b_y, self.b_x + 30, self.b_y + 30,fill='orange', start=60, extent = 90, tag='bola') pass def VerificaColisao(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 numero de colisoes for diferente de zero if len(colisoes) != 0: #Verificamos se a id do objeto é diferente do player if colisoes[0] != self.player: #vamos checar se ha colisão cm o objeto mais proximo do #topo esquerdo da bola m_p = self.canvas.find_closest(coord[0], coord[1]) #depois temos que olhar para cada um dos retangulos para #identificar com q bola colidiu for r in self.r: #tendo encontrado o retangulo 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 sai fora return
from retangulo import Retangulo comprimento = float(input("Digite o valor do comprimento do local: ")) largura = float(input("Digite o valor da largura do local: ")) piso = Retangulo() lag_piso = float(input("Digite a largura do piso ")) com_piso = float(input("Digite o comprimento do piso ")) piso.mudar_valores(lag_piso, com_piso) area_total = largura * comprimento num_pisos = area_total / piso.calcula_area() print(num_pisos)
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
# Arquivo principal do programa. from circulo import Circulo # Do arquivo circulo importe a classe Circulo from retangulo import Retangulo # Do arq retangulo importa a classe Retangulo print("Escolha qual forma deseja utilizar nos calculos!") forma = int(input("1-Circulo\n2-Retangulo\n->")) if forma == 1: # Se foi escolhido a forma 1 (Circulo) raio = float(input("Quantos centimetros tem o raio: ")) # Entrada de dados meuCirculo = Circulo(raio) # Na variavel meuCirculo cria um novo # objeto do tipo Circulo, passando raio como parâmetro meuCirculo.calc_area() # Chama o método calc_area print("A área do circulo é %5.2fcm²!" % meuCirculo.area) meuCirculo.calc_perimetro() # Chama o método calc_perimetro print("O perímetro do circulo é %5.2fcm!" % meuCirculo.perimetro) elif forma == 2: altura = int(input("Digite a medida da altura do retangulo: ")) # Entrada de dados largura = int(input("Digite a medida da largura do retangulo: ")) meuRetangulo = Retangulo(altura, largura) # Na variavel meuretangulo cria um novo # objeto do tipo Retangulo, passando ladoMaior e ladoMenor como parâmetros meuRetangulo.calc_area() # Chama o método calc_area print("A área do retangulo é %5.2fcm²!" % meuRetangulo.area) meuRetangulo.calc_perimetro() # Chama o método calc_perimetro print("O perímetro do retangulo é %5.2fcm!" % meuRetangulo.perimetro) else: print("Opição inválida...")
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
class Test_Retangulo(unittest.TestCase): def setUp(self): self.retangulo = Retangulo(3,5) def test_alterar_e_consltar_altura(self): self.retangulo.alterar_altura(2) self.retangulo.consultar_altura() |should| equal_to(2) def test_alterar_e_consultar_base(self): self.retangulo.alterar_base(6) self.retangulo.consultar_base() |should| equal_to(6) def test_calcular_area(self): self.retangulo.calcular_area() |should| equal_to(15) def test_nao_aceita_valores_negativos_nem_0(self): (self.retangulo._validar_altura_, 0) |should| throw(ValueError) (self.retangulo._validar_base_, -6) |should| throw(ValueError) def test_calcular_area_e_obter_perimetro(self): self.retangulo.alterar_altura(5) self.retangulo.alterar_base(4) self.retangulo.consultar_altura() |should| equal_to(5) self.retangulo.consultar_base() |should| equal_to(4) self.retangulo.calcular_area() |should| equal_to(20) self.retangulo.obter_perimetro() |should| equal_to(18)
import pygame from bola import Bola from retangulo import Retangulo bola = Bola() retangulo = Retangulo(0, 0, 0, 0) largura_tela = 400 altura_tela = 400 screen_wh = largura_tela, altura_tela velocidade_x = 5 velocidade_y = 5 BLACK = (0, 0, 0) relogio = pygame.time.Clock() retangulos = [] def cria_bola(): pos_x = 200 pos_y = 380 raio = 20 bola.set_centro_x(pos_x) bola.set_centro_y(pos_y) bola.set_raio(raio)
def main(): quadrado = Quadrado(5) retangulo = Retangulo(5,10) circunferencia = Circunferencia(10) print(circunferencia.calcularArea(), retangulo.calcularArea(), quadrado.calcularArea())
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
def setUp(self): self.retangulo = Retangulo(5, 2)
from retangulo import Retangulo #receber do usuarios as medidas lado_a = int(input("Informe a medida do lado A do local:")) lado_b = int(input("Informe a medida do lado B do local:")) lado_a_piso = int(input("Informe a medida do lado A do piso:")) lado_b_piso = int(input("Informe a medida do lado B do piso:")) sala = Retangulo(lado_a, lado_b) piso = Retangulo(lado_a_piso, lado_b_piso) sala.retornar_vlr_lado() area_sala = sala.calculo_area() area_piso = piso.calculo_area() perimetro_sala = sala.calculo_perimetro() piso.calculo_perimetro() qtd_pisos = (area_sala / area_piso) print("A qtd de pisos necessarios é:", qtd_pisos) qtd_rodape = (perimetro_sala / lado_a_piso) print("A qtd de rodape necessarios é:", qtd_rodape)
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
def main(instance): print("Server: " + str(platform.node()) + "\n") # Obtem os valores do arquivo e cria os retângulos # filename = 'problema1.data' filename = instance boxes, Lu, Wu, Hu = get_data(filename) filename = filename.replace('.data', '', 1) filename = filename.replace('instances/', '', 1) print(filename) # Cria os conjuntos X,Y,Z BigX, BigY, BigZ = [], [], [] for i in boxes: # Percorrer cada tipo de caixa p, q, r = 0, 0, 0 for e in range(1, i.get('qtd') + 1): l = i.get('dim')[0] p += e * l for e in range(1, i.get('qtd') + 1): l = i.get('dim')[1] q += e * l for e in range(1, i.get('qtd') + 1): l = i.get('dim')[2] r += e * l BigX.append(p) BigY.append(q) BigZ.append(r) container = [Lu, Wu, Hu] BigX = [i for i in range(sum(BigX))] BigY = [i for i in range(sum(BigY))] BigZ = [i for i in range(sum(BigZ))] # print(BigX, BigY, BigZ, sep='\n') m = Model("3D-ODRPP") m.setParam('TimeLimit', 1 * 3600.0) L = m.addVar(vtype=GRB.CONTINUOUS, name="L", lb=0, ub=GRB.INFINITY) W = m.addVar(vtype=GRB.CONTINUOUS, name="W", lb=0, ub=GRB.INFINITY) H = m.addVar(vtype=GRB.CONTINUOUS, name="H", lb=0, ub=GRB.INFINITY) z_obj = m.addVar(vtype=GRB.CONTINUOUS, name="Z", lb=0, ub=GRB.INFINITY) m.addConstr(z_obj == L + W + H, "z_objective") m.setObjective(z_obj, GRB.MINIMIZE) X, Y, Z = [], [], [] for i, box in enumerate(boxes, start=0): li = box.get('dim')[0] wi = box.get('dim')[1] hi = box.get('dim')[2] X_i = [p for p in range(0, Lu - li)] Y_i = [p for p in range(0, Wu - wi)] Z_i = [p for p in range(0, Hu - hi)] X.append(X_i) Y.append(Y_i) Z.append(Z_i) # print(X, Y, Z, sep='\n') # Criação das variáveis binárias x_bin = [] for i, box in enumerate(boxes): rotations = list(permutations(box.get('dim'))) # print(box.get('dim'), rotations, sep='\t') k_list = [] for k, b in enumerate(rotations): p_list = [] for p in X[i]: q_list = [] for q in Y[i]: r_list = [] for r in Z[i]: index = '[' + str(i) + '][' + str(k) + '][' + str( p) + '][' + str(q) + '][' + str(r) + ']' x = m.addVar(vtype=GRB.BINARY, name='X_' + index) r_list.append(x) q_list.append(r_list) p_list.append(q_list) k_list.append(p_list) x_bin.append(k_list) print(' = Variables Added') # Constraint 2 for s in BigX: for t in BigY: for u in BigZ: soma_r2 = LinExpr() for i, box in enumerate(boxes, start=0): rotations = list(permutations(box.get('dim'))) for k, b in enumerate(rotations): li, wi, hi = b[0], b[1], b[2] for p in X[i]: for q in Y[i]: for r in Z[i]: if s - li + 1 <= p <= s: if t - wi + 1 <= q <= t: if u - hi + 1 <= r <= u: soma_r2 += x_bin[i][k][p][q][r] # index = str(i) index = '[' + str(s) + '][' + str(t) + '][' + str(u) + ']' m.addConstr(soma_r2 <= 1, name='Restricao2_' + index) print(' = Constraint 2 adicionada') # Constraint 3 for j, box in enumerate(boxes, start=0): bj = box.get('qtd') soma_r3 = LinExpr() rotations = list(permutations(box.get('dim'))) for k, b in enumerate(rotations): for p in X[j]: for q in Y[j]: for r in Z[j]: soma_r3 += x_bin[j][k][p][q][r] m.addConstr(soma_r3 == bj, name='Restricao3_' + str(j)) print(' = Constraint 3 adicionada') # Restrições 4, 5 e 6 for i, box in enumerate(boxes, start=0): rotations = list(permutations(box.get('dim'))) for k, b in enumerate(rotations): for p in X[i]: for q in Y[i]: for r in Z[i]: index = '[' + str(i) + '][' + str(k) + '][' + str( p) + '][' + str(q) + '][' + str(r) + ']' li, wi, hi = b[0], b[1], b[2] algo_p = (p + li) * x_bin[i][k][p][q][r] algo_q = (q + wi) * x_bin[i][k][p][q][r] algo_r = (r + hi) * x_bin[i][k][p][q][r] m.addConstr(algo_p <= L, name='Restricao4_' + index) m.addConstr(algo_q <= W, name='Restricao5_' + index) m.addConstr(algo_r <= H, name='Restricao6_' + index) print(' = Restrições 4,5,6 adicionadas') m.write('models/modelo_' + filename + '.lp') print(' = Model written!') m.optimize() if m.status == GRB.Status.OPTIMAL: m.write('results/resultado_' + filename + '.sol') print('Container: ', Lu, Wu, Hu, sep='\t') print('\nFunção objetivo: ', str(round(L.X)), str(round(W.X)), str(round(W.X)), sep='\t') # Recupera as posições das caixas solutions = [] for i, box in enumerate(boxes, start=0): sol_box = [] for k in range(6): for p in X[i]: for q in Y[i]: for r in Z[i]: if x_bin[i][k][p][q][r].X == 1: sol_box.append([i, (p, q, r), k]) solutions.append(sol_box) # solutions = [[[0, (3, 0, 0), 0], [0, (4, 0, 0), 0]], [[1, (0, 0, 0), 1], [1, (0, 3, 0), 1]], # [[2, (1, 0, 4), 2], [2, (2, 0, 4), 4]], [[3, (1, 1, 5), 1], [3, (2, 2, 5), 4], [3, (1, 3, 5), 5]]] ret = [] for i, box in enumerate(boxes): color_b = np.random.rand(1, 3) rotated_box = list(permutations(box.get('dim'))) for j in range(box.get('qtd')): sol = solutions[i][j] r = rotated_box[sol[2]] r = Retangulo(vertex=r, color=color_b) r.change_vertex(list(sol[1])) ret.append(r) ret.sort(key=lambda x: max(x.vertex[2]), reverse=True) file_write_list = open('results/retangulos_' + filename + '.bin', 'wb') pickle.dump(ret, file_write_list)
from retangulo import Retangulo r1 = Retangulo(5, 6) print("Área do retangulo: ", r1.calcularArea())
from retangulo import Retangulo retanguo1 = Retangulo(8, 5) retanguo1.imprimir_valores() retanguo1.imprimir_area()
def given_um_retangulo(context, x, y, w, h): """Cria objeto retangulo com os parametros especificados.""" context.retangulo = Retangulo(x, y, w, h)
def setUp(self): self.retangulo = Retangulo(3, 5)
def escolha(): forma = input( "1 - Circulo\n2 - Retangulo\n3 - Triangulo\n4 - Trapézio\n5 - Sair\n-->" ) # menu de opções try: # utilizamos o try para tratar teclas que não sejam numéricas com excessão do ponto para valores flutuantes if forma == "1": raio = float(input("Quantos centimetros tem o raio:")) meuCirculo = Circulo(raio) # instaciando a classe minhaarea = meuCirculo.calcularAreacirc( ) # recebendo a area da classe circulo meuperimetro = meuCirculo.calculaPerimetrocirc( ) # recebendo o perimetro da classe circulo print("\nA area do círculo é {:.2f} cm".format(minhaarea)) print("\nO Perimetro do Círculo é {:.2f} cm ".format(meuperimetro)) elif forma == "2": base = float(input("Digite a base do retangulo: ") ) # recebndo os valores e setando nas variaveis altura = float(input("Digite a altura do retangulo: ")) meuRetangulo = Retangulo( base, altura ) # instanciando a minha classe e enviando meus parametros areareta = meuRetangulo.calcularAreareta( ) # chamando a classe para receber o resultado meuperi = meuRetangulo.calculaPerimetroreta( ) # #chamando a classe para receber o resultado print("\nA area do retangulo é {:.2f} cm²".format( areareta)) # apresentando a area do circulo para o usuario print("\nO perimetro do retangulo é {:.2f} cm".format( meuperi)) # apresentando a area do circulo para o usuario elif forma == "3": lado1 = float(input("Digite o lado 1 do triangulo: ") ) # recebndo os valores e setando nas variaveis lado2 = float(input("Digite o laodo 2 do triangulo: ")) base = float(input("Digite a base do triangulo: ") ) # recebndo os valores e setando nas variaveis altura = float(input("Digite a altura do triangulo: ")) meuTriangulo = Triangulo( lado1, lado2, base, altura ) # instanciando a minha classe e enviando meus parametros areatri = meuTriangulo.calcularAreaTri( ) # chamando a classe para receber o resultado peritri = meuTriangulo.calculaPerimetroTri( ) # #chamando a classe para receber o resultado print("\nA area do triangulo é {:.2f} cm²".format( areatri)) # apresentando a area do circulo para o usuario print("\nO perimetro do triangolo é {:.2f} cm".format( peritri)) # apresentando a area do circulo para o usuario elif forma == "4": lado1 = float(input("Digite o lado 1 do trapezio: ") ) # recebndo os valores e setando nas variaveis lado2 = float(input("Digite o laodo 2 do trapezio: ")) basemenor = float(input("Digite a base Menor do trapezio: ") ) # recebndo os valores e setando nas variaveis basemaior = float(input("Digite a base Maior do trapezio: ") ) # recebndo os valores e setando nas variaveis altura = float(input("Digite a altura do trapezio: ")) meuTrapezio = Trapezio( lado1, lado2, basemenor, basemaior, altura ) # instanciando a minha classe e enviando meus parametros areatrap = meuTrapezio.calcularAreaTrap( ) # chamando a classe para receber o resultado peritrap = meuTrapezio.calculaPerimetroTrap( ) # #chamando a classe para receber o resultado print("\nA area do trapezio é {:.2f} cm²".format( areatrap)) # apresentando a area do circulo para o usuario print("\nO perimetro do trapezio é {:.2f} cm".format( peritrap)) # apresentando a area do circulo para o usuario elif forma == "5": print("ATÉ A PRÓXIMA!!!") # despedida exit() #finaliza o programa else: print( "Opção inválida, a escolha deve ser uma operação da lista!\nPor Favor, tente novamente." ) # caso usuário digite tecla que não faz parte das opções escolha() # chamada da função para reinicialização do programa except ValueError: # excessão do try, valor recebido errado, que não seja número print( "Opção inválida, Não utilize letras, virgula ou deixe vazio!\nA entrada deve ser primeiro um número seguido ou não de ponto!\nPor Favor, tente novamente." ) escolha() # chamada da função para reinicialização do programa
pygame.init() fundo = pygame.display.set_mode((400, 400)) pygame.display.set_caption('Retangulo') preto = (0, 0, 0) branco = (255, 255, 255) azul = (0, 0, 255) verde = (0, 255, 0) vermelho = (255, 0, 0) cor1 = (220, 50, 50) cor2 = (100, 100, 0) cor3 = (50, 100, 150) cor4 = (255, 200, 0) #def __init__(self, posX, posY, largura, altura, cor): a1 = Retangulo(10, 10, 10, 10, vermelho) a2 = Retangulo(35, 10, 10, 10, branco) a3 = Retangulo(60, 10, 10, 10, azul) a4 = Retangulo(85, 10, 10, 10, verde) a5 = Retangulo(110, 10, 10, 10, cor1) a6 = Retangulo(135, 10, 10, 10, cor2) a7 = Retangulo(135, 10, 10, 10, cor3) a8 = Retangulo(160, 10, 10, 10, cor4) a9 = Retangulo(185, 10, 10, 10, verde) a10 = Retangulo(210, 10, 10, 10, branco) b1 = Retangulo(10, 35, 10, 10, vermelho) b2 = Retangulo(35, 35, 10, 10, branco) b3 = Retangulo(60, 35, 10, 10, azul) b4 = Retangulo(85, 35, 10, 10, verde) b5 = Retangulo(110, 35, 10, 10, cor1)
def main(instance, model_file): print("Server: " + str(platform.node()) + "\n") # Obtem os valores do arquivo e cria os retângulos filename = instance boxes, Lu, Wu, Hu = get_data(filename) filename = filename.replace('.data', '', 1) filename = filename.replace('instances/', '', 1) print(filename) m = read(model_file) print('Problema: ' + m.getAttr('modelName')) m.setParam('TimeLimit', 1 * 3600.0) vars = m.getVars() z_obj, L, W, H = vars[0], vars[1], vars[2], vars[3] X, Y, Z = [], [], [] for i, box in enumerate(boxes, start=0): li = box.get('dim')[0] wi = box.get('dim')[1] hi = box.get('dim')[2] X_i = [p for p in range(0, Lu - li)] Y_i = [p for p in range(0, Wu - wi)] Z_i = [p for p in range(0, Hu - hi)] X.append(X_i) Y.append(Y_i) Z.append(Z_i) m.optimize() # Recuperar as variáveis binárias x_bin = [] for i, box in enumerate(boxes): rotations = list(permutations(box.get('dim'))) k_list = [] for k, b in enumerate(rotations): p_list = [] for p in X[i]: q_list = [] for q in Y[i]: r_list = [] for r in Z[i]: index = 'X_' + '{}_{}_{}_{}_{}'.format(i, k, p, q, r) x = m.getVarByName(index) r_list.append(x) q_list.append(r_list) p_list.append(q_list) k_list.append(p_list) x_bin.append(k_list) print(' = Variables Added') if True: m.write('results/resultado_' + filename + '.sol') print('Container: ', Lu, Wu, Hu, sep='\t') container = [Lu, Wu, z_obj.X] print('\nFunção objetivo: ', container[0], container[1], container[2], sep='\t') # Recupera as posições das caixas solutions = [] for i, box in enumerate(boxes, start=0): sol_box = [] for k in range(6): for p in X[i]: for q in Y[i]: for r in Z[i]: if x_bin[i][k][p][q][r].X == 1: sol_box.append([i, (p, q, r), k]) solutions.append(sol_box) ret = [] for i, box in enumerate(boxes): color_b = np.random.rand(1, 3) rotated_box = list(permutations(box.get('dim'))) for j in range(box.get('qtd')): sol = solutions[i][j] r = rotated_box[sol[2]] r = Retangulo(vertex=r, color=color_b) r.change_vertex(list(sol[1])) ret.append(r) ret.sort(key=lambda x: max(x.vertex[2]), reverse=True) file_write_list = open('results/retangulos_' + filename + '.bin', 'wb') pickle.dump(ret, file_write_list) visualiser = PolyVisualiser( array_polygons=ret, x_lim=container[0], y_lim=container[1], z_lim=container[2], obj=container[2], alpha=.8, title=filename, ) visualiser.animate(no_animation=False) visualiser.scrol() visualiser.show()
def setUp(self): self.retangulo = Retangulo(3, 10)
# ----Quadrado------------------ print(' Configuração para a Quadrado!') vquadrado = Quadrado() vquadrado.tamanho_lado = int(input('Digite o lado para o quadrado: ')) vquadrado.trocaLado(vquadrado.tamanho_lado) vquadrado.mostraInfoQuadrado() print(''' Quadrado configurado! ''') # -----Retangulo---------------- print(' Configuração para Retangulo!') vretangulo = Retangulo() vretangulo.lado_a = int(input('Informe o lado A: ')) vretangulo.lado_b = int(input('Informe o lado B: ')) vretangulo.setaLados(vretangulo.lado_a, vretangulo.lado_b) vretangulo.mostraInfoRetangulo() print(''' Retangulo configurado! ''')
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