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
