def inicia_partida(self):
time.sleep(0.5)
self.paletas = [
Paleta([30, 125], [pygame.K_w, pygame.K_s]),
Paleta([560, 125], [pygame.K_UP, pygame.K_DOWN])
]
self.bola = Bola()
def __init__(self,trampolin, modo, nivel, versus, ventana, tamaño=None, time=TIEMPO_NIVEL1):
self.pantalla = pygame.display.set_mode((ANCHO,LARGO))
pygame.display.set_caption("Pong")
self.FILAS = 30
self.COLUMNAS = 40
self.matriz = []
self.crearMatriz()
self.score = 0
self.bola = Bola(20,12, random.randrange(-1, 2), True)
self.nivel = nivel
self.modo = modo
self.versus = versus
self.CPU = 0
self.tamaño = tamaño
self.time = time
self.ventana = ventana
self.trampolin = trampolin
self.trampolin1 = Barra(10,5,4,2)
self.trampolin2 = Barra(30,15,4,2)
self.trampolin3 = Barra(20,10,4,2)
self.musicOn = 1
self.musicSpeed = 1
self.background_color = (0, 0, 0)
self.playMusic()
# Se define el tiempo, tamaño de barra, modo y versus de cada nivel
if self.nivel == 1:
if self.time == None:
self.tiempo = TIEMPO_NIVEL1
else:
self.tiempo = time
if self.modo == "Single":
if self.tamaño == None:
self.barra1 = Barra(1,2,TAMAÑO_BARRA_1,1)
self.barra2 = Barra(38,2,TAMAÑO_BARRA_1,1)
else:
# Si se le define un tamaño es porque está en modo práctica
self.barra1 = Barra(1,2,self.tamaño,1)
self.barra2 = Barra(38,0,TAMAÑO_BARRA_PRACTICA,1)
if self.versus == "humano":
self.CPU = 0
elif self.versus == "cpu":
self.CPU = 1
else:
# La primer barra es la de la izquiera, la otra la de la derecha
if self.tamaño == None:
self.barra1 = Barra_doble(1,2,9,13,TAMAÑO_BARRA_1)
self.barra2 = Barra_doble(38,12,30,3,TAMAÑO_BARRA_1)
else:
self.barra1 = Barra_doble(1,2,9,13,self.tamaño)
self.barra2 = Barra(38,0,TAMAÑO_BARRA_PRACTICA,1)
if self.versus == "humano":
# Si se escoje "humano" no se llama la función cpu()
self.CPU = 0
elif self.versus == "cpu":
self.CPU = 1
class Gerenciadora:
def __init__(self):
self.tela = Tela()
self.placar = Placar()
self.inicia_partida()
def inicia_partida(self):
time.sleep(0.5)
self.paletas = [
Paleta([30, 125], [pygame.K_w, pygame.K_s]),
Paleta([560, 125], [pygame.K_UP, pygame.K_DOWN])
]
self.bola = Bola()
def roda_loop(self):
while True:
cliques = self.monitora_cliques()
if pygame.QUIT in cliques:
break
if self.placar.total_partidas() < 5:
self.movimenta_objetos()
if self.placar.atualiza(self.paletas, self.bola):
self.inicia_partida()
self.tela.renderiza(self.paletas, self.bola, self.placar)
else:
if pygame.MOUSEBUTTONUP in cliques:
# Verificar coordenadas do mouse:
# pygame.mouse.get_pos()
self.placar = Placar()
pygame.time.Clock().tick(60)
def monitora_cliques(self):
cliques = []
for evento in pygame.event.get():
if evento.type == pygame.QUIT:
cliques.append(pygame.QUIT)
if evento.type == pygame.MOUSEBUTTONUP:
cliques.append(pygame.MOUSEBUTTONUP)
return cliques
def movimenta_objetos(self):
teclas = pygame.key.get_pressed()
for paleta in self.paletas:
paleta.movimenta(teclas)
self.bola.movimenta()
def __init__(self,
modo,
nivel,
versus,
tamaño=TAMAÑO_BARRA_1,
time=TIEMPO_NIVEL1):
pygame.init()
self.pantalla = pygame.display.set_mode((ANCHO, LARGO))
pygame.display.set_caption("Pong")
self.FILAS = 30
self.COLUMNAS = 40
self.matriz = []
self.crearMatriz()
self.score = 0
self.bola = Bola(20, 12, random.randrange(-1, 2), True)
self.nivel = nivel
self.modo = modo
self.versus = versus
self.CPU = 0
self.tamaño = tamaño
self.time = time
# Se define el tiempo, tamaño de barra, modo y versus de cada nivel
if self.nivel == 1:
if self.time == None:
self.tiempo = TIEMPO_NIVEL1
else:
self.tiempo = time
if self.modo == "Single":
if self.tamaño == None:
self.barra1 = Barra(1, 2, TAMAÑO_BARRA_1)
self.barra2 = Barra(38, 2, TAMAÑO_BARRA_1)
else:
self.barra1 = Barra(1, 2, self.tamaño)
self.barra2 = Barra(38, 2, self.tamaño)
if self.versus == "humano":
self.CPU = 0
elif self.versus == "cpu":
self.CPU = 1
else:
# La primer barra es la de la izquiera, la otra la de la derecha
if self.tamaño == None:
self.barra1 = Barra_doble(1, 3, 9, 13, TAMAÑO_BARRA_1)
self.barra2 = Barra_doble(38, 12, 30, 3,
TAMAÑO_BARRA_1)
else:
self.barra1 = Barra(1, 2, self.tamaño)
self.barra2 = Barra(38, 2, self.tamaño)
if self.versus == "humano":
# Si se escoje "humano" no se llama la función cpu()
self.CPU = 0
elif self.versus == "cpu":
self.CPU = 1
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 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
def main():
cor = input("Informe a cor da bola :")
circuferencia = input("Informe a circuferencia da bola :")
material = input("Informe o material da bola :")
bola = Bola(cor, circuferencia, material)
print(bola)
print("Informe 1 para trocar a cor !")
print("Informe 2 para mostrar a cor !")
escolha = input("Informe sua escolha !")
while escolha != '0':
if escolha == '1':
cor = input("Informe a nova cor :")
bola.trocacor(cor)
print(cor)
break
elif escolha == '2':
bola.mostracor(cor)
break
def test_is_clicked(self):
bola = Bola((50, 50))
self.assertTrue(bola.is_clicked(PhysicalObject((51, 52))))
self.assertFalse(bola.is_clicked(PhysicalObject((60, 52))))
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 test_consultar_cor_da_bola(self):
bola = Bola("lilas")
bola.obter_cor() | should | equal_to("lilas")
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
# Classe Bola: Crie uma classe que modele uma bola:
# Atributos: Cor, circunferência, material
# Métodos: trocaCor e mostraCor
from bola import Bola
bola1 = Bola('branca', '50cm', 'plástico')
print(bola1.circuferencia)
def test_alterar_cor_da_bola(self):
bola = Bola("Verde")
bola.alterar_cor("Vermelha")
bola.obter_cor() | should | equal_to("Vermelha")
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
from bola import Bola
modelo1 = Bola("Verde", 3, "Canarinha")
print("***Modelando a Bola***")
print("Cor:", modelo1.cor, "Circunferencia:", modelo1.circunferencia,
"Material:", modelo1.material)
nova_cor = input("Digite uma nova cor para a bola: ")
modelo1.troca_cor(nova_cor)
modelo1.mostra_cor()
def test_alterar_cor_da_bola(self):
bola = Bola("Verde")
bola.alterar_cor("Vermelha")
bola.obter_cor() |should| equal_to("Vermelha")
def test_consultar_cor_da_bola(self):
bola = Bola("lilas")
bola.obter_cor() |should| equal_to("lilas")
# license removed for brevity
from bola import Bola
from robo import Robo
from aliado import Aliado
from bola import Bola
from campo import Campo
import numpy
import rospy
from geometry_msgs.msg import Pose
if __name__ == '__main__':
rospy.init_node('goleiro', anonymous=True)
try:
campo = Campo()
bola = Bola("/ball/pose")
goleiro = Aliado("/player1/pose",
"/player1__VSS_player__chassi_left_wheel/joint_vel",
"/player1__VSS_player__chassi_right_wheel/joint_vel")
artilheiro = Robo("/player2/pose")
# rate = rospy.Rate(10)
while not rospy.is_shutdown():
goleiro.move_goleiro(campo, bola)
# rate.sleep()
except rospy.ROSInterruptException:
pass
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
class Juego:
def __init__(self,trampolin, modo, nivel, versus, ventana, tamaño=None, time=TIEMPO_NIVEL1):
self.pantalla = pygame.display.set_mode((ANCHO,LARGO))
pygame.display.set_caption("Pong")
self.FILAS = 30
self.COLUMNAS = 40
self.matriz = []
self.crearMatriz()
self.score = 0
self.bola = Bola(20,12, random.randrange(-1, 2), True)
self.nivel = nivel
self.modo = modo
self.versus = versus
self.CPU = 0
self.tamaño = tamaño
self.time = time
self.ventana = ventana
self.trampolin = trampolin
self.trampolin1 = Barra(10,5,4,2)
self.trampolin2 = Barra(30,15,4,2)
self.trampolin3 = Barra(20,10,4,2)
self.musicOn = 1
self.musicSpeed = 1
self.background_color = (0, 0, 0)
self.playMusic()
# Se define el tiempo, tamaño de barra, modo y versus de cada nivel
if self.nivel == 1:
if self.time == None:
self.tiempo = TIEMPO_NIVEL1
else:
self.tiempo = time
if self.modo == "Single":
if self.tamaño == None:
self.barra1 = Barra(1,2,TAMAÑO_BARRA_1,1)
self.barra2 = Barra(38,2,TAMAÑO_BARRA_1,1)
else:
# Si se le define un tamaño es porque está en modo práctica
self.barra1 = Barra(1,2,self.tamaño,1)
self.barra2 = Barra(38,0,TAMAÑO_BARRA_PRACTICA,1)
if self.versus == "humano":
self.CPU = 0
elif self.versus == "cpu":
self.CPU = 1
else:
# La primer barra es la de la izquiera, la otra la de la derecha
if self.tamaño == None:
self.barra1 = Barra_doble(1,2,9,13,TAMAÑO_BARRA_1)
self.barra2 = Barra_doble(38,12,30,3,TAMAÑO_BARRA_1)
else:
self.barra1 = Barra_doble(1,2,9,13,self.tamaño)
self.barra2 = Barra(38,0,TAMAÑO_BARRA_PRACTICA,1)
if self.versus == "humano":
# Si se escoje "humano" no se llama la función cpu()
self.CPU = 0
elif self.versus == "cpu":
self.CPU = 1
# Se crea auna matriz binaria(compuesta por ahora por 0s), de 25 filas x 40 columnas
def crearMatriz(self):
for i in range(self.FILAS):
fila = []
for j in range(self.COLUMNAS):
# Llena la lista de ceros
fila.append(0)
self.matriz.append(fila)
# Se va dibujando la matriz cuadro pr cuadro y se plasma en la pantalla
def dibujarMatriz(self):
for fila in range(self.FILAS):
for columna in range(self.COLUMNAS):
if self.matriz[fila][columna] == 0:
# Si el cierta posición de la matriz hay un 0, se pinta de color negro
pygame.draw.rect(self.pantalla, self.background_color, [L* columna,L * fila,L,L])
elif self.matriz[fila][columna] == 2:
# Si el cierta posición de la matriz hay un 0, se pinta de color negro
pygame.draw.rect(self.pantalla, GREEN, [L* columna,L * fila,L,L])
else:
# Si el cierta posición de la matriz hay un 0, se pinta de color blanco
# Esto es para la bola y las barras
pygame.draw.rect(self.pantalla, WHITE, [L* columna,L * fila,L,L])
# Define cada cuánto tiempo se va a actualizar la matriz
time.sleep(self.time)
# Sibuja una línea blanca en medio de la pantalla
pygame.draw.line(self.pantalla, WHITE, [ANCHO//2, 0], [ANCHO//2,LARGO], 4)
# Barra controlada por la computadora
def cpu(self):
# La posicion en x de la bola es mayor a 28
if self.bola.get_x() > 28:
if self.bola.get_y() > self.barra2.get_y():
# Si la posición en y de la bola es mayor que la de la barra
# se mueve la barra hacia arriba o abajo siguiendo la bola
self.barra2.mover(-1, self.matriz)
else:
self.barra2.mover(1, self.matriz)
def jugar(self):
global ventana, total, total1, total2, total3
fuera_juego = False
# Genera múltiples eventos pygame.KEYDOWN
pygame.key.set_repeat(50, 50)
inicial = time.time()
while not fuera_juego:
# Si el score de alguno de los jugadores es igual a 5
if self.versus != "practica":
if self.bola.get_score1() == 5 or self.bola.get_score2() == 5:
# Se reinician los scores
self.bola.set_score1(0)
self.bola.set_score2(0)
# Se pasa de nivel
self.nivel += 1
self.musicSpeed += 1
self.playMusic()
# Si pierde en el nivel 3, vuelve al nivel 1
if self.nivel == 4:
total = str((time.time()-inicial))
self.archivarTiempos(total)
pygame.quit()
# Se limpia la matriz para dibujar las barras del siguiente nivel
self.matriz = []
# Se vuelve a crear la matriz
self.crearMatriz()
# Se definen las condiciones de acuerdo con cada nivel
if self.nivel == 1:
self.tiempo = TIEMPO_NIVEL1
if self.modo == "Single":
self.barra1 = Barra(1,2,TAMAÑO_BARRA_1,1)
self.barra2 = Barra(38,2,TAMAÑO_BARRA_1,1)
else:
self.barra1 = Barra_doble(1,2,9,13,TAMAÑO_BARRA_1)
self.barra2 = Barra_doble(38,12,32,3,TAMAÑO_BARRA_1)
elif self.nivel == 2:
self.tiempo = TIEMPO_NIVEL2
if self.modo == "Single":
self.barra1 = Barra(1,2,TAMAÑO_BARRA_2,1)
self.barra2 = Barra(38,2,TAMAÑO_BARRA_2,1)
else:
self.barra1 = Barra_doble(1,2,9,13,TAMAÑO_BARRA_2)
self.barra2 = Barra_doble(38,12,30,3,TAMAÑO_BARRA_2)
elif self.nivel == 3:
self.tiempo = TIEMPO_NIVEL3
if self.modo == "Single":
self.barra1 = Barra(1,2,TAMAÑO_BARRA_3,1)
self.barra2 = Barra(38,2,TAMAÑO_BARRA_3,1)
else:
self.barra1 = Barra_doble(1,2,9,13,TAMAÑO_BARRA_3)
self.barra2 = Barra_doble(38,12,30,3,TAMAÑO_BARRA_3)
else:
if self.bola.get_score1() == 100:
# Se reinician los scores
self.bola.set_score1(0)
# Se pasa de nivel
self.nivel += 1
self.musicSpeed +=1
self.playMusic()
# Se limpia la matriz para dibujar las barras del siguiente nivel
self.matriz = []
# Se vuelve a crear la matriz
self.crearMatriz()
if self.nivel == 1:
self.tiempo = self.time
if self.tamaño != None:
if self.modo == "Single":
self.barra1 = Barra(1,2,self.tamaño,1)
self.barra2 = Barra(38,0,TAMAÑO_BARRA_PRACTICA,1)
else:
self.barra1 = Barra_doble(1,3,9,13,self.tamaño)
self.barra2 = Barra(38,0,TAMAÑO_BARRA_PRACTICA,1)
# Eventos de las teclas
pygame.init()
for event in pygame.event.get():
if event.type == pygame.QUIT: #is le da X, cierra todo
pygame.quit()
quit()
if event.type == pygame.KEYDOWN: #al presionar una tecla
if event.key == pygame.K_UP:
self.barra2.mover(1,self.matriz)
elif event.key == pygame.K_DOWN:
self.barra2.mover(-1,self.matriz)
elif event.key == pygame.K_w:
self.barra1.mover(1,self.matriz)
elif event.key == pygame.K_s:
self.barra1.mover(-1,self.matriz)
elif event.key == pygame.K_ESCAPE:
pygame.quit()
quit()
elif event.key == pygame.K_p:
self.pausa()
elif event.key == pygame.K_SPACE:
pygame.quit()
quit()
# Aquí se actualiza constántemente la matriz para que
# ocurra el movimiento de forma continua
self.dibujarMatriz()
self.dibujar()
# Lee los estimulos del Arduino
self.leerArduino()
self.sendArduino()
# se llama la función cpu solo si la variable CPU es igual a 1
if self.CPU == 1:
self.cpu()
def dibujar(self):
# Se defne un texto para poner en la pantalla
font = pygame.font.Font(None, 100)
score1 = self.bola.get_score1()
score_text = font.render(str(score1), True,
(WHITE))
# Se coloca el texto en la pantalla
self.pantalla.blit(score_text, (150, 0))
score2 = self.bola.get_score2()
score_text2 = font.render(str(score2), True,
(WHITE))
self.pantalla.blit(score_text2, (620, 0))
# Coloca la bola en la matriz
self.bola.mover(self.matriz)
# Posiciona las barras en la matriz
self.barra1.posicionar(self.matriz)
self.barra2.posicionar(self.matriz)
if self.trampolin == 1:
if self.versus == "practica":
if self.time == TIEMPO_NIVEL1:
self.trampolin3.posicionar(self.matriz)
elif self.time == TIEMPO_NIVEL2:
self.trampolin1.posicionar(self.matriz)
self.trampolin2.posicionar(self.matriz)
elif self.time == TIEMPO_NIVEL3:
self.trampolin1.posicionar(self.matriz)
self.trampolin2.posicionar(self.matriz)
self.trampolin3.posicionar(self.matriz)
else:
if self.nivel == 1:
self.trampolin3.posicionar(self.matriz)
elif self.nivel == 2:
self.trampolin1.posicionar(self.matriz)
self.trampolin2.posicionar(self.matriz)
elif self.nivel == 3:
self.trampolin1.posicionar(self.matriz)
self.trampolin2.posicionar(self.matriz)
self.trampolin3.posicionar(self.matriz)
pygame.display.update()
def playMusic(self):
pygame.init()
if self.musicSpeed == 1:
back_music = pygame.mixer.music.load(os.path.join("sounds", "music.ogg"))
elif self.musicSpeed == 2:
back_music = pygame.mixer.music.load(os.path.join("sounds", "music_speed2.ogg"))
elif self.musicSpeed == 3:
back_music = pygame.mixer.music.load(os.path.join("sounds", "music_speed3.ogg"))
if self.musicOn == 1:
pygame.mixer.music.play(-1)
else:
pygame.mixer.music.play(-1)
pygame.mixer.music.pause()
# Cambia el color por uno aleatorio
def colorCycle(self):
self.background_color = (random.randrange(0, 256), random.randrange(0, 256), random.randrange(0, 256))
# Lee las instrucciones del Arduino con Pyserial
def leerArduino(self):
try:
entrada = str(ser.readline())
datos = entrada[entrada.index("") + 1: entrada.index("\\")]
comando = datos[:datos.index("%")]
print(comando)
if comando == "'P1_UP":
self.barra1.mover(1, self.matriz)
elif comando == "'P1_DOWN":
self.barra1.mover(-1, self.matriz)
elif comando == "'P2_UP":
self.barra2.mover(1, self.matriz)
elif comando == "'P2_DOWN":
self.barra2.mover(-1, self.matriz)
elif comando == "'MUTE":
if self.musicOn == 1:
self.musicOn = 0
pygame.mixer.music.pause()
self.bola.set_mute(1)
else:
self.musicOn = 1
pygame.mixer.music.unpause()
self.bola.set_mute(0)
elif comando == "'COLOR":
self.colorCycle()
except:
print('NO INPUT')
time.sleep(0.0001)
#def sendArduino(self):
# if self.bola.get_score1() == 0:
# ser.write(b'0')
# elif self.bola.get_score1() == 1:
# ser.write(b'1')
# elif self.bola.get_score1() == 2:
# ser.write(b'2')
# elif self.bola.get_score1() == 3:
# ser.write(b'3')
# elif self.bola.get_score1() == 4:
# ser.write(b'4')
# elif self.bola.get_score1() == 5:
# ser.write(b'5')
# if self.bola.get_score2() == 0:
# ser.write(b'6')
# elif self.bola.get_score2() == 1:
# ser.write(b'7')
# elif self.bola.get_score2() == 2:
# ser.write(b'8')
# elif self.bola.get_score2() == 3:
# ser.write(b'9')
# elif self.bola.get_score2() == 4:
# ser.write(b':')
# elif self.bola.get_score2() == 5:
# ser.write(b';')
def archivarTiempos(self, total):
vent = Tk()
vent.title("Mejores Tiempos de Juego")
vent.minsize (800, 500)
vent.config(bg="black")
pygame.quit()
def unirLista(matriz): # Invierte las funciones de separar para la modificación del archivo txt
if matriz == []:
return []
else:
return [";".join(matriz[0])] + unirLista(matriz[1:])
def abrirArchivo(archivo, modo): #abre el archivo
file = open(archivo, modo)
return file
def separarTiempos(i):
if i == len(highscore):
return
highscore[i] = highscore[i].replace("\n", "").split(";")
separarTiempos(i + 1)
archivo = abrirArchivo("Tiempos.txt", "r")
highscore = archivo.readlines()
separarTiempos(0)
#print(highscore)
archivo.close()
def highscores():
iniciales = entradaNombre.get()
if iniciales != "":
if len(highscore) < 3:
registrar = open("Tiempos.txt", "a") #abre un archivo
registrar.write(iniciales + ";" + total + "\n") #escribe en el archivo
registrar.close()
else:
if iniciales != highscore[0][0] and total != highscore[0][1]:
if iniciales != highscore[1][0] and total != highscore[1][1]:
if iniciales != highscore[2][0] and total != highscore[2][1]:
return highscores_aux(total, iniciales)
else:
messagebox.showerror("Error en los datos", "No es record")
else:
messagebox.showerror("Error en los datos", "No es record")
else:
messagebox.showerror("Error en los datos", "No es record")
else:
messagebox.showerror("Error en los datos", "Ingrese sus iniciales")
def highscores_aux(valor, iniciales):
if valor < highscore[2][1]:
hacer = True
if iniciales != "":
if valor <= highscore[0][1] and hacer:
highscore[2][0] = highscore[1][0]
highscore[2][1] = highscore[1][1]
highscore[1][0] = highscore[0][0]
highscore[1][1] = highscore[0][1]
highscore[0][0] = iniciales
highscore[0][1] = valor
hacer = False
if valor <= highscore[1][1] and valor > highscore[0][1] and hacer:
highscore[2][0] = highscore[1][0]
highscore[2][1] = highscore[1][1]
highscore[1][0] = iniciales
highscore[1][1] = valor
hacer = False
if valor < highscore[2][1] and valor > highscore[1][1] and hacer:
highscore[2][0] = iniciales
highscore[2][1] = valor
nuevo_texto = "\n".join(unirLista(highscore))
archivo_highscores = abrirArchivo("Tiempos.txt", "w")
archivo_highscores.write((str(nuevo_texto)))
tiempo1.config(text = highscore[0][0] + " " + str(highscore[0][1]))
tiempo2.config(text = highscore[1][0] + " " + str(highscore[1][1]))
tiempo3.config(text = highscore[2][0] + " " + str(highscore[2][1]))
labelNombre = Label(vent, text = "¡Tiempo récord! \n Ingrese sus iniciales:", font = ("arial bold", 30), bg = "black", fg = "yellow")
labelNombre.place (x = 200, y = 250)
entradaNombre = Entry (vent, font = ("arial", 16), width = 25, bg = "grey")
entradaNombre.place (x = 257, y = 380)
if len(highscore) == 3:
tiempo1 = Label(vent, text = highscore[0][0] + " " + str(highscore[0][1]), font = ("arial bold", 16), bg = "black", fg = "white")
tiempo1.place (x = 80, y = 100)
tiempo2 = Label(vent, text = highscore[1][0] + " " + str(highscore[1][1]), font = ("arial bold", 16), bg = "black", fg = "white")
tiempo2.place (x = 80, y = 150)
tiempo3 = Label(vent, text = highscore[2][0] + " " + str(highscore[2][1]), font = ("arial bold", 16), bg = "black", fg = "white")
tiempo3.place (x = 80, y = 200)
else:
label = Label(vent,text = "Nuevo record!", bg = "black", fg = "white", font = ("arial bold", 16))
label.place(x = 80, y = 100)
boton = Button (vent, text = "Agregar", font = ("arial", 12), width = 6, command = highscores)
boton.place (x = 120, y = 10)
def listo():
vent.destroy()
pygame.quit()
self.ventana.deiconify()
boton = Button (vent, text = "Volver al menú", font = ("arial", 12), width = 6, command = listo)
boton.place (x = 200, y = 10)
vent.mainloop()
def crearVentana(): #Abre una nueva ventana donde hay dos botones: Administrar Apps y Administrar Vendedores
vent = Tk()
vent.title("Mejores Tiempos de Juego")
vent.minsize (800, 500)
canvas1 = Canvas (vent, width = 800, height = 500)
canvas1.place (x = -1, y = -1)
def volver():
vent.destroy()
self.ventana.deiconify()
boton = Button (vent, font = ("arial", 12), width = 6, command = volver)
boton.place (x = 120, y = 10)
vent.mainloop()
pygame.quit()
crearVentana()
def pausa(self):
pausado = True
while pausado:
pantalla = pygame.display.set_mode((ANCHO,LARGO))
font = pygame.font.Font(None, 25)
for x in range (self.FILAS):
score_text = font.render(str(self.matriz[x]), True,(WHITE))
# Se coloca el texto en la pantalla
pantalla.blit(score_text, (20, 20*x))
pygame.display.update()
for event in pygame.event.get():
if event.type == pygame.QUIT: #is le da X, cierra todo
pygame.quit()
quit()
if event.type == pygame.KEYDOWN: #al presionar una tecla
if event.key == pygame.K_p:
pausado = False
pygame.quit()
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)
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
class Juego:
def __init__(self, modo, nivel, versus, tamaño=None, time=TIEMPO_NIVEL1):
pygame.init()
self.pantalla = pygame.display.set_mode((ANCHO, LARGO))
pygame.display.set_caption("Pong")
self.FILAS = 30
self.COLUMNAS = 40
self.matriz = []
self.crearMatriz()
self.score = 0
self.bola = Bola(20, 12, random.randrange(-1, 2), True)
self.nivel = nivel
self.modo = modo
self.versus = versus
self.CPU = 0
self.tamaño = tamaño
self.time = time
# Se define el tiempo, tamaño de barra, modo y versus de cada nivel
if self.nivel == 1:
if self.time == None:
self.tiempo = TIEMPO_NIVEL1
else:
self.tiempo = time
if self.modo == "Single":
if self.tamaño == None:
self.barra1 = Barra(1, 2, TAMAÑO_BARRA_1)
self.barra2 = Barra(38, 2, TAMAÑO_BARRA_1)
else:
# Si se le define un tamaño es porque está en modo práctica
self.barra1 = Barra(1, 2, self.tamaño)
self.barra2 = Barra(38, 0, TAMAÑO_BARRA_PRACTICA)
if self.versus == "humano":
self.CPU = 0
elif self.versus == "cpu":
self.CPU = 1
else:
# La primer barra es la de la izquiera, la otra la de la derecha
if self.tamaño == None:
self.barra1 = Barra_doble(1, 3, 9, 13, TAMAÑO_BARRA_1)
self.barra2 = Barra_doble(38, 12, 32, 3,
TAMAÑO_BARRA_1)
else:
self.barra1 = Barra_doble(1, 3, 9, 13, self.tamaño)
self.barra2 = Barra(38, 0, TAMAÑO_BARRA_PRACTICA)
if self.versus == "humano":
# Si se escoje "humano" no se llama la función cpu()
self.CPU = 0
elif self.versus == "cpu":
self.CPU = 1
# Se crea auna matriz binaria(compuesta por ahora por 0s), de 25 filas x 40 columnas
def crearMatriz(self):
for i in range(self.FILAS):
fila = []
for j in range(self.COLUMNAS):
# Llena la lista de ceros
fila.append(0)
self.matriz.append(fila)
# Se va dibujando la matriz cuadro pr cuadro y se plasma en la pantalla
def dibujarMatriz(self):
for fila in range(self.FILAS):
for columna in range(self.COLUMNAS):
if self.matriz[fila][columna] == 0:
# Si el cierta posición de la matriz hay un 0, se pinta de color negro
pygame.draw.rect(self.pantalla, BLACK,
[L * columna, L * fila, L, L])
else:
# Si el cierta posición de la matriz hay un 0, se pinta de color blanco
# Esto es para la bola y las barras
pygame.draw.rect(self.pantalla, WHITE,
[L * columna, L * fila, L, L])
# Define cada cuánto tiempo se va a actualizar la matriz
time.sleep(self.tiempo)
# Sibuja una línea blanca en medio de la pantalla
pygame.draw.line(self.pantalla, WHITE, [ANCHO // 2, 0],
[ANCHO // 2, LARGO], 4)
# Barra controlada por la computadora
def cpu(self):
# La posicion en x de la bola es mayor a 28
if self.bola.get_x() > 28:
if self.bola.get_y() > self.barra2.get_y():
# Si la posición en y de la bola es mayor que la de la barra
# se mueve la barra hacia arriba o abajo siguiendo la bola
self.barra2.mover(-1, self.matriz)
else:
self.barra2.mover(1, self.matriz)
def jugar(self):
fuera_juego = False
# Genera múltiples eventos pygame.KEYDOWN
pygame.key.set_repeat(50, 50)
while not fuera_juego:
# Si el score de alguno de los jugadores es igual a 5
if self.versus != "practica":
if self.bola.get_score1() == 5 or self.bola.get_score2() == 5:
# Se reinician los scores
self.bola.set_score1(0)
self.bola.set_score2(0)
# Se pasa de nivel
self.nivel += 1
# Se limpia la matriz para dibujar las barras del siguiente nivel
self.matriz = []
# Se vuelve a crear la matriz
self.crearMatriz()
# Se definen las condiciones de acuerdo con cada nivel
if self.nivel == 1:
self.tiempo = TIEMPO_NIVEL1
if self.modo == "Single":
self.barra1 = Barra(1, 2, TAMAÑO_BARRA_1)
self.barra2 = Barra(38, 2, TAMAÑO_BARRA_1)
else:
self.barra1 = Barra_doble(1, 3, 9, 13,
TAMAÑO_BARRA_1)
self.barra2 = Barra_doble(38, 12, 32, 3,
TAMAÑO_BARRA_1)
if self.nivel == 2:
self.tiempo = TIEMPO_NIVEL2
if self.modo == "Single":
self.barra1 = Barra(1, 2, TAMAÑO_BARRA_2)
self.barra2 = Barra(38, 2, TAMAÑO_BARRA_2)
else:
self.barra1 = Barra_doble(1, 3, 9, 13,
TAMAÑO_BARRA_2)
self.barra2 = Barra_doble(38, 12, 32, 3,
TAMAÑO_BARRA_2)
if self.nivel == 3:
self.tiempo = TIEMPO_NIVEL3
if self.modo == "Single":
self.barra1 = Barra(1, 2, TAMAÑO_BARRA_3)
self.barra2 = Barra(38, 2, TAMAÑO_BARRA_3)
else:
self.barra1 = Barra_doble(1, 3, 9, 13,
TAMAÑO_BARRA_3)
self.barra2 = Barra_doble(38, 12, 32, 3,
TAMAÑO_BARRA_3)
# Si pierde en el nivel 3, vuelve al nivel 1
if self.nivel == 4:
if self.bola.get_score1() == 5:
font = pygame.font.Font(None, 48)
texto = font.render(
"¡Felicidades!", "Has aprobado INTRO & TALLER.\
\nListo para ALGORITMOS Y ESTRUCTURAS DE DATOS I. :D", True, (WHITE))
self.pantalla.blit(texto, (0, 0))
self.nivel = 0
else:
if self.bola.get_score1() == 100:
# Se reinician los scores
self.bola.set_score1(0)
# Se pasa de nivel
self.nivel += 1
# Se limpia la matriz para dibujar las barras del siguiente nivel
self.matriz = []
# Se vuelve a crear la matriz
self.crearMatriz()
if self.nivel == 1:
self.tiempo = self.time
if self.tamaño != None:
if self.modo == "Single":
self.barra1 = Barra(1, 2, self.tamaño)
self.barra2 = Barra(38, 0,
TAMAÑO_BARRA_PRACTICA)
else:
self.barra1 = Barra_doble(
1, 3, 7, 13, self.tamaño)
self.barra2 = Barra(38, 0,
TAMAÑO_BARRA_PRACTICA)
# Eventos de las teclas
for event in pygame.event.get():
if event.type == pygame.QUIT: #is le da X, cierra todo
pygame.quit()
quit()
if event.type == pygame.KEYDOWN: #al presionar una tecla
if event.key == pygame.K_UP:
self.barra2.mover(1, self.matriz)
elif event.key == pygame.K_DOWN:
self.barra2.mover(-1, self.matriz)
elif event.key == pygame.K_w:
self.barra1.mover(1, self.matriz)
elif event.key == pygame.K_s:
self.barra1.mover(-1, self.matriz)
elif event.key == pygame.K_ESCAPE:
pygame.quit()
quit()
# Aquí se actualiza constántemente la matriz para que
# ocurra el movimiento de forma continua
self.dibujarMatriz()
self.dibujar()
# Lee los estimulos del Arduino
#self.leerArduino()
# se llama la función cpu solo si la variable CPU es igual a 1
if self.CPU == 1:
self.cpu()
def dibujar(self):
# Se defne un texto para poner en la pantalla
font = pygame.font.Font(None, 100)
score1 = self.bola.get_score1()
score_text = font.render(str(score1), True, (WHITE))
# Se coloca el texto en la pantalla
self.pantalla.blit(score_text, (150, 0))
score2 = self.bola.get_score2()
score_text2 = font.render(str(score2), True, (WHITE))
self.pantalla.blit(score_text2, (620, 0))
# Coloca la bola en la matriz
self.bola.mover(self.matriz)
# Posiciona las barras en la matriz
self.barra1.posicionar(self.matriz)
self.barra2.posicionar(self.matriz)
pygame.display.update()
def leerArduino(self):
try:
entrada = str(ser.readline())
datos = entrada[entrada.index("") + 1:entrada.index("\\")]
comando = datos[:datos.index("%")]
print(comando)
if comando == "'P1_UP":
self.barra1.mover(1, self.matriz)
elif comando == "'P1_DOWN":
self.barra1.mover(-1, self.matriz)
except:
print('NO INPUT')
time.sleep(0.0001)
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
from bola import Bola
from quadrado import Quadrado
from retangulo import Retangulo
print('''
Edição de Polígonos!
''')
# ----Bola -----------------
print(' Configuração para a Bola!')
cor_nova = Bola()
cor_nova.cor = input('Digite a nova cor para a bola: ')
cor_nova.trocaCor(cor_nova.cor)
cor_nova.mostrarCor()
print('''
Bola configurada!
''')
# ----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)
def test_criar_bola(self):
bola = Bola("Verde")
