class Game_scene(Scene):
def __init__(self, game):
super(Game_scene, self).__init__(screen, manager)
screen_size = self.screen.get_size()
self.balle = Balle(self.screen,
(screen_size[0] / 2, screen_size[1] / 2),
speed=0.5)
self.balle.direction = Direction.DOWN_RIGHT
barre_size = (5, 64)
self.barres = (Barre(self.screen, size=barre_size, speed=1),
Barre(self.screen,
coords=(screen_size[0] - barre_size[0],
screen_size[1] - barre_size[1]),
size=barre_size,
controls={
Direction.UP: pygame.K_o,
Direction.DOWN: pygame.K_l
},
speed=1))
def update(self, evts):
self.collis()
self.events(evts)
self.balle.update()
for barre in self.barres:
barre.update()
pygame.display.update()
def events(self, evts):
for evt in evts:
if evt.type == pygame.USEREVENT:
self.balle.reset()
def collis(self):
balleRect = pygame.Rect(self.balle.coords,
(self.balle.size, self.balle.size))
for idx in range(len(self.barres)):
barreRect = pygame.Rect(self.barres[idx].coords,
self.barres[idx].size)
if (balleRect.colliderect(barreRect)):
if idx == 0:
if (self.balle.direction == Direction.LEFT):
self.balle.direction = Direction.RIGHT
elif self.balle.direction == Direction.DOWN_LEFT:
self.balle.direction = Direction.DOWN_RIGHT
elif self.balle.direction == Direction.UP_LEFT:
self.balle.direction = Direction.UP_RIGHT
elif idx == 1:
if self.balle.direction == Direction.RIGHT:
self.balle.direction = Direction.LEFT
elif self.balle.direction == Direction.UP_RIGHT:
self.balle.direction = Direction.UP_LEFT
elif self.balle.direction == Direction.DOWN_RIGHT:
self.balle.direction = Direction.DOWN_LEFT
self.balle.speed *= 1.01
def __init__(self):
self.en_jeu = True
self.balle = Balle()
self.raquette = Raquette()
self.niveau = Niveau()
self.vie = NOMBRE_VIES
self.score = 0
self.briques_touchees = 0
class Game:
def __init__(self, window: pygame.Surface):
self.window = window
self.proceed = True
self.barre = Barre(self.window)
self.balle = Balle(self.window)
self.controles = {HAUT: const.K_UP, BAS: const.K_DOWN}
def prepare(self):
pygame.key.set_repeat(200, 50)
self.proceed = True
self.barre = Barre(self.window)
self.balle = Balle(self.window)
def update_screen(self):
pygame.draw.rect(self.window, (0, 0, 0),
(0, 0) + self.window.get_size())
pygame.draw.rect(
self.window, (255, 255, 255),
(self.window.get_width() // 2 - 1, 0, 2, self.window.get_height()))
self.barre.render()
self.balle.render()
def process_event(self, event: pygame.event):
if event.type == const.KEYDOWN:
if event.key == self.controles[HAUT]:
self.barre.move(HAUT)
if event.key == self.controles[BAS]:
self.barre.move(BAS)
if event.type == const.QUIT:
self.proceed = False
def start(self):
self.prepare()
clock = pygame.time.Clock()
done = False
ball_list = []
ball = self.balle.make_ball()
ball_list.append(ball)
while not done:
# --- Event Processing
for event in pygame.event.get():
self.process_event(event)
if event.type == pygame.QUIT:
done = True
elif event.type == pygame.KEYDOWN:
ball_list.append(ball)
self.balle.move(self.barre)
self.update_screen()
clock.tick(60)
pygame.display.flip()
def __init__(self, i_fenetre):
'''
Définition des variables du constructeur.
'''
self.fenetre = i_fenetre # Stocke les paramètres de la fenêtre.
self.canevas = tk.Canvas(
self.fenetre,
width=self.largeur_fenetre(),
height=self.hauteur_fenetre(
)) # Crée un canvas ( Support de tout les éléments d'affichage. )
self.canevas.place(x=0, y=0) # Place le Canvas
self.raquette = Raquette(self) # Crée une instance de Raquette.
self.balle = Balle(self) # Crée une instance de Balle.
self.level_id = -1 # Numéro du niveau à charger.
self.niveau = Level(self,
self.level_id) # Crée une instance du Niveau .
self.lives = Lives(self, 3,
self.largeur_fenetre() / 16,
(self.hauteur_fenetre() * 15) /
16) # Crée une instance des Vies.
self.touche_possible = [
"q", "d", "Q", "D"
] # Liste des touches qui seront utilisées pour jouer.
self.touche_options = [
'plus', 'minus', 'slash'
] # Liste des touches qui seront utilisées pour les options du jeu (Augmenter le taux de rafraîchissement : +, le Diminuer : -, Mettre en place un sol : / ).
# Capture les événements de la souris.
self.canevas.bind(
"<Motion>",
self.moved) # Coordonnées du curseur de la souris en abscisse.
self.canevas.bind("<Button-3>",
self.rightClick) # Si le click droit a été activé.
self.canevas.bind(
"<Leave>",
self.leave) # Si la souris a quitté le périmètre de la fenêtre.
self.canevas.bind(
"<Enter>",
self.enter) # Si la souris est entrée le périmètre de la fenêtre.
# Capture les événements du clavier.
self.fenetre.bind(
"<KeyPress>", self.checkKeyPressed
) # Active la capture des touches du clavier dans la fenêtre.
self.resetGame(
) # Initialise tout les objets avec leurs paramètres par défaut.
class Game:
def __init__(self, ecran: pygame.Surface):
self.ecran = ecran
self.raquette = Raquette(self.ecran)
self.balle = Balle(self.ecran)
self.continuer = True
self.controles = {HAUT: const.K_UP, BAS: const.K_DOWN}
def prepare(self):
pygame.key.set_repeat(200, 50)
self.continuer = True
self.raquette = Raquette(self.ecran)
self.balle = Balle(self.ecran)
def update_screen(self):
pygame.draw.rect(self.ecran, (0, 0, 0),
(0, 0) + self.ecran.get_size()) # on dessine le fond
pygame.draw.rect(
self.ecran, (255, 255, 255),
(self.ecran.get_width() // 2 - 1, 0, 2,
self.ecran.get_height())) # la séparation au milieu du terrain
self.raquette.render() # on dessine notre raquette
self.balle.render() # on dessine notre balle
def process_event(self, event: pygame.event):
if event.type == const.KEYDOWN:
# et revoici l'utilité de nos constantes, utilisées comme clé de dictionnaire :)
# comme ça on peut plus facilement changer les controles ;)
if event.key == self.controles[HAUT]:
self.raquette.move(HAUT)
if event.key == self.controles[BAS]:
self.raquette.move(BAS)
if event.type == const.QUIT:
self.continuer = False
def start(self):
self.prepare()
while self.continuer:
for event in pygame.event.get():
self.process_event(event)
self.update_screen()
self.balle.move(self.raquette) # on déplace notre balle
pygame.display.flip()
def __init__(self, game):
super(Game_scene, self).__init__(screen, manager)
screen_size = self.screen.get_size()
self.balle = Balle(self.screen,
(screen_size[0] / 2, screen_size[1] / 2),
speed=0.5)
self.balle.direction = Direction.DOWN_RIGHT
barre_size = (5, 64)
self.barres = (Barre(self.screen, size=barre_size, speed=1),
Barre(self.screen,
coords=(screen_size[0] - barre_size[0],
screen_size[1] - barre_size[1]),
size=barre_size,
controls={
Direction.UP: pygame.K_o,
Direction.DOWN: pygame.K_l
},
speed=1))
def __init__(self):
self.ecran = pygame.display.set_mode((900, 500))
pygame.display.set_caption('Jeu Pong')
self.jeu_encours = True
self.joueur_1_x, self.joueur_1_y = 20, 250
self.joueur_2_x, self.joueur_2_y = 860, 250
self.joueur_taille = [20, 80]
self.vitesse_y_1, self.vitesse_y_2 = 0, 0
self.joueur_1 = Joueur(self.joueur_1_x, self.joueur_1_y,
self.joueur_taille)
self.joueur_2 = Joueur(self.joueur_2_x, self.joueur_2_y,
self.joueur_taille)
self.rect = pygame.Rect(0, 0, 900, 500)
self.balle_direction = [-1, 1]
self.balle = Balle(450, 250, [10, 10],
random.choice(self.balle_direction))
self.balle_tire = False
self.balle_vitesse_x, self.balle_vitesse_y = 15, 2
self.score_1, self.score_2 = 0, 0
def __init__(self, window: pygame.Surface):
self.window = window
self.proceed = True
self.barre = Barre(self.window)
self.balle = Balle(self.window)
self.controles = {HAUT: const.K_UP, BAS: const.K_DOWN}
def prepare(self):
pygame.key.set_repeat(200, 50)
self.proceed = True
self.barre = Barre(self.window)
self.balle = Balle(self.window)
class Jeu:
'''
Classe pour gérer l'ensemble des intéractions avec le jeu.
'''
def __init__(self, i_fenetre):
'''
Définition des variables du constructeur.
'''
self.fenetre = i_fenetre # Stocke les paramètres de la fenêtre.
self.canevas = tk.Canvas(
self.fenetre,
width=self.largeur_fenetre(),
height=self.hauteur_fenetre(
)) # Crée un canvas ( Support de tout les éléments d'affichage. )
self.canevas.place(x=0, y=0) # Place le Canvas
self.raquette = Raquette(self) # Crée une instance de Raquette.
self.balle = Balle(self) # Crée une instance de Balle.
self.level_id = -1 # Numéro du niveau à charger.
self.niveau = Level(self,
self.level_id) # Crée une instance du Niveau .
self.lives = Lives(self, 3,
self.largeur_fenetre() / 16,
(self.hauteur_fenetre() * 15) /
16) # Crée une instance des Vies.
self.touche_possible = [
"q", "d", "Q", "D"
] # Liste des touches qui seront utilisées pour jouer.
self.touche_options = [
'plus', 'minus', 'slash'
] # Liste des touches qui seront utilisées pour les options du jeu (Augmenter le taux de rafraîchissement : +, le Diminuer : -, Mettre en place un sol : / ).
# Capture les événements de la souris.
self.canevas.bind(
"<Motion>",
self.moved) # Coordonnées du curseur de la souris en abscisse.
self.canevas.bind("<Button-3>",
self.rightClick) # Si le click droit a été activé.
self.canevas.bind(
"<Leave>",
self.leave) # Si la souris a quitté le périmètre de la fenêtre.
self.canevas.bind(
"<Enter>",
self.enter) # Si la souris est entrée le périmètre de la fenêtre.
# Capture les événements du clavier.
self.fenetre.bind(
"<KeyPress>", self.checkKeyPressed
) # Active la capture des touches du clavier dans la fenêtre.
self.resetGame(
) # Initialise tout les objets avec leurs paramètres par défaut.
def largeur_fenetre(self) -> int:
'''
Fonction qui retourne la valeur de la largeur de la fenêtre.
'''
return self.fenetre.winfo_width(
) # Retourne la largeur définie dans main.py
def hauteur_fenetre(self) -> int:
'''
Fonction qui retourne la valeur de la hauteur de la fenêtre.
'''
return self.fenetre.winfo_height(
) # Retourne la heuteur définie dans main.py
def checkKeyPressed(self, event):
'''
Fonction qui vérifie si une touche à été préssée, et si elle est prise en compte par le programme.
'''
# print(f"Touche : {event.keysym}") #Affiche toutes les touches préssés.
if event.keysym == "Escape": # Si la touche préssée est 'Echap' alors ,
self.stopGame(
) #Le jeu s'arrête (Sortie de la boucle while -> infini)
if event.keysym in self.touche_possible: # Si la touche préssée est dans la liste de celles possibles pour le jeu.
if event.keysym == "q" or event.keysym == "Q": # Si la touche préssée est la touche 'q' ou 'Q' (dans le cas d'un clavier en mode MAJS )
self.raquette.goLeft(
) # Apelle la fonction qui permet de déplacer la Raquette vers la Gauche.
elif event.keysym == "d" or event.keysym == "D": # Si la touche préssée est la touche 'd' ou 'D' (dans le cas d'un clavier en mode MAJS )
self.raquette.goRight(
) # Apelle la fonction qui permet de déplacer la Raquette vers la Droite.
if event.keysym in self.touche_options: # Si la touche préssée est dans la liste de celles possibles pour les options.
if event.keysym == "plus": # Si la touche préssée est la touche '+'
self.time_sleep /= 2 # Le taux de rafraîchissement de la fenêtre est augmenté (temps de pause diminué).
print("Taux de Rafraîchissement : Augmenté"
) # Message qui s'affiche au passage dans la condition.
elif event.keysym == "minus": # Si la touche préssée est la touche '-'
self.time_sleep *= 2 # Le taux de rafraîchissement de la fenêtre est diminué (temps de pause augmenté).
print("Taux de Rafraîchissement : Diminué"
) # Message qui s'affiche au passage dans la condition.
elif event.keysym == 'slash': # Si la touche préssée est la touche '/'
self.niveau.ground = not self.niveau.ground # Toggle (= Basculer) le sol à True / False.
if self.niveau.ground == True: # Si le sol est à l'état True.
print(
"Sol Activé"
) # Message qui s'affiche au passage dans la condition.
else: # Sinon
print(
"Sol Désactivé"
) # Message qui s'affiche si le sol est désactivé après passage dans la boucle.
def moved(self, event):
'''
Fonction récupérant les coordonnées en abscisse de la souris et les attribuants à la raquette.
'''
x = event.x # Capte les coordonées de la souris en abscisse.
self.raquette.setPosition(
x
) # Attributs les coordonnées en abscisse de la souris captés précédement et les attributs à la Raquette.
def enter(self, event):
'''
Fonction qui gère l'entrée de la souris dans la zone du canvas.
'''
x, y = event.x, event.y # Capture les coordonnées en abscisse, en ordonné et les stockent.
if y > 0 and y < self.hauteur_fenetre(
): # Si la souris est dans la fenêtre en hauteur alors ,
self.raquette.setPositionEnter(
x
) # On demande à placer la souris au maximum de la zone du canvas en largeur.
def leave(self, event):
'''
Fonction qui gère la sortie de la souris de la zone du canvas.
'''
x, y = event.x, event.y # Capture les coordonnées en abscisse, en ordonné et les stockent.
if y > 0 and y < self.hauteur_fenetre(
): # Si la souris est dans la fenêtre en hauteur alors ,
self.raquette.setPositionLeave(
x
) # On demande à placer la souris au maximum de la zone du canvas en largeur.
def miseAJour(self):
'''
Fonction mettant à jour tout les éléments susceptibles de varier // Sauf les briques (Auto gérées)
'''
self.balle.deplacer() # Provoque le déplacement de la Balle.
self.balle.paint() # Actualise l'affichage de la Balle.
self.raquette.paint() # Actualise l'affichage de la Raquette.
self.lives.paint() # Actualise l'affichage de la Vie.
def stopGame(self):
'''
Fonction permettant d'arrêter le jeu.
'''
self.running = False # Sortie de la bouble infini While.
print("Game Stopped"
) # Message qui s'affiche lors de l'appel de cette fonction.
def getStateGame(self):
'''
Fonction permettant d'obtenir l'état du jeu (Pause/Running).
'''
return self.running # Retourne True si le jeu est en marche, sinon, s'il est arrêté, retourne False.
def resetGame(self):
'''
Réinitialise tout les paramètres par défaut de tout les objets.
'''
self.raquette.reset() # Réinitialise les paramètres de la Raquette.
self.balle.reset() # Réinitialise les paramètres de la Balle.
self.lives.reset() # Réinitialise les paramètres de la Vie.
self.niveau.reset() # Réinitialise les paramètres du Niveau.
self.time_sleep = 0.01 # Réinitialise les paramètres de temps de pause du jeu.
def rightClick(self, event):
'''
Fonction permettant de rédémarrer le Jeu avec un clic droit si le Jeu est en pause.
'''
if self.getStateGame() == False: # Si le Jeu est en pause alors ,
self.resetGame(
) # L'on réinitialise tout les paramètres par défaut.
self.startGame() # L'on rentre dans la boucle infini While.
def startGame(self):
'''
Fonction permattant de démarrer le Jeu.
'''
self.running = True # Passe la condition de la boucle infini While à l'état : True (l'on rentre dans la boucle).
while self.getStateGame(): # Tant que le Jeu est à l'état True :
self.miseAJour() # Mise à jour du jeu.
self.fenetre.update() # Mise à jour par l'os de l'affichage.
sleep(
self.time_sleep
) # Temps d'arrêt entre chaque rafraîchissement de l'écran qui est défini par : self.time_sleep .
def __init__(self, ecran: pygame.Surface):
self.ecran = ecran
self.raquette = Raquette(self.ecran)
self.balle = Balle(self.ecran)
self.continuer = True
self.controles = {HAUT: const.K_UP, BAS: const.K_DOWN}
def prepare(self):
pygame.key.set_repeat(200, 50)
self.continuer = True
self.raquette = Raquette(self.ecran)
self.balle = Balle(self.ecran)
class Jeu:
def __init__(self):
self.en_jeu = True
self.balle = Balle()
self.raquette = Raquette()
self.niveau = Niveau()
self.vie = NOMBRE_VIES
self.score = 0
self.briques_touchees = 0
def gestion_evenements(self):
for event in pygame.event.get():
if event.type == pygame.QUIT: sys.exit()
elif event.type == pygame.MOUSEBUTTONDOWN:
if event.button == 1:
if self.balle.sur_raquette:
self.balle.sur_raquette = False
self.balle.vitesse_par_angle(60)
if self.en_jeu == False:
self.vie = NOMBRE_VIES
self.niveau.en_cours = 1
self.score = 0
def mise_a_jour(self):
x, y = pygame.mouse.get_pos()
self.balle.deplacer(self.raquette)
if self.balle.loose:
self.vie -= 1
self.balle.loose = False
prec = False
for brique in self.niveau.brique_liste:
if brique.en_vie():
collision = brique.collision_balle(self.balle,prec)
if collision[0]:
if not(prec):
if brique.vie > 0:
jouer_son("touche")
else:
jouer_son("score")
if collision[0] and not(collision[1]) :
self.score += 1
self.raquette.arc_en_ciel = True
self.briques_touchees += 1
prec = True
self.raquette.deplacer(x)
self.en_jeu = True
def affichage(self):
screen.fill(COULEURS["NOIR"])
afficher_murs()
afficher_ATH(self)
self.balle.afficher()
self.raquette.afficher()
self.niveau.afficher()
def game_over(self):
screen.fill(COULEURS["NOIR"])
if jeu.vie == 0 :
texte, rect = myfont.render("GAME OVER", (255,255,255), size = monitorwidth/15)
else :
texte, rect = myfont.render("GAME WIN", (255,255,255), size = monitorwidth/15)
rect.center = (int(width/2), int(height/2))
screen.blit(texte, rect)
texte, rect = myfont.render("SCORE : " + str(self.score), (255,255,255), size = monitorwidth/38)
rect.midtop = (int(width/2), int(height/5*3))
screen.blit(texte, rect)
texte, rect = myfont.render("NIVEAU : " + str(self.niveau.en_cours-1), (255,255,255), size = monitorwidth/38)
rect.midbottom = (int(width/2), int(height/5*2))
screen.blit(texte, rect)
self.en_jeu = False
class Jeu:
def __init__(self):
self.ecran = pygame.display.set_mode((900, 500))
pygame.display.set_caption('Jeu Pong')
self.jeu_encours = True
self.joueur_1_x, self.joueur_1_y = 20, 250
self.joueur_2_x, self.joueur_2_y = 860, 250
self.joueur_taille = [20, 80]
self.vitesse_y_1, self.vitesse_y_2 = 0, 0
self.joueur_1 = Joueur(self.joueur_1_x, self.joueur_1_y,
self.joueur_taille)
self.joueur_2 = Joueur(self.joueur_2_x, self.joueur_2_y,
self.joueur_taille)
self.rect = pygame.Rect(0, 0, 900, 500)
self.balle_direction = [-1, 1]
self.balle = Balle(450, 250, [10, 10],
random.choice(self.balle_direction))
self.balle_tire = False
self.balle_vitesse_x, self.balle_vitesse_y = 15, 2
self.score_1, self.score_2 = 0, 0
def boucle_principale(self):
while self.jeu_encours:
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_UP:
self.vitesse_y_1 = -10
if event.key == pygame.K_DOWN:
self.vitesse_y_1 = 10
if event.key == pygame.K_w:
self.vitesse_y_2 = -10
if event.key == pygame.K_s:
self.vitesse_y_2 = 10
if event.key == pygame.K_SPACE:
self.balle_tire = True
if event.type == pygame.KEYUP:
if event.key == pygame.K_UP:
self.vitesse_y_1 = 0
if event.key == pygame.K_DOWN:
self.vitesse_y_1 = 0
if event.key == pygame.K_w:
self.vitesse_y_2 = 0
if event.key == pygame.K_s:
self.vitesse_y_2 = 0
self.joueur_1.mouvement(self.vitesse_y_1)
self.joueur_2.mouvement(self.vitesse_y_2)
self.joueur_1.rect.clamp_ip(self.rect)
self.joueur_2.rect.clamp_ip(self.rect)
if self.balle_tire:
self.balle.mouvement(self.balle_vitesse_x,
self.balle_vitesse_y)
if self.joueur_1.rect.colliderect(
self.balle.rect) or self.joueur_2.rect.colliderect(
self.balle.rect):
self.balle_vitesse_x = self.changement_direction_balle(
self.balle_vitesse_x, 0)
self.balle_vitesse_y = self.changement_direction_balle(
self.balle_vitesse_y, 60)
self.balle.vitesse_aleatoire_y = random.randint(1, 7)
if self.balle.rect.top <= 0 or self.balle.rect.bottom >= 500:
self.balle_vitesse_y = self.changement_direction_balle(
self.balle_vitesse_y, 0)
if self.balle.rect.right >= 915:
self.balle.rect.x, self.balle.rect.y = 450, 250
self.score_1 += 1
self.balle_tire = False
if self.balle.rect.left <= -15:
self.balle.rect.x, self.balle.rect.y = 450, 250
self.score_2 += 1
self.balle_tire = False
self.balle.rect.clamp_ip(self.rect)
self.ecran.fill((50, 50, 50))
self.creer_message('grande', f"Jeu Pong", [300, 50, 20, 20],
(255, 255, 255))
self.creer_message('grande', f" { self.score_1 }",
[300, 200, 50, 50], (255, 255, 255))
self.creer_message('grande', f" { self.score_2 }",
[485, 200, 50, 50], (255, 255, 255))
if self.balle_tire is False:
self.creer_message(
'petite', f" Appuyer Sur Espace Pour Commencer Le Jeu",
[30, 100, 300, 50], (255, 255, 255))
self.balle.afficher(self.ecran)
self.joueur_1.afficher(self.ecran)
self.joueur_2.afficher(self.ecran)
pygame.display.flip()
def changement_direction_balle(self, vitesse, angle):
vitesse = -(vitesse * math.cos(angle))
return vitesse
def creer_message(self, font, message, message_rectangle, couleur):
if font == 'petite':
font = pygame.font.Font(
'/Users/karimsadiki/Desktop/Pong Game/ATARCC__.TTF', 20)
if font == 'moyenne':
font = pygame.font.Font(
'/Users/karimsadiki/Desktop/Pong Game/ATARCC__.TTF', 30)
if font == 'grande':
font = pygame.font.Font(
'/Users/karimsadiki/Desktop/Pong Game/ATARCC__.TTF', 40)
message = font.render(message, True, couleur)
self.ecran.blit(message, message_rectangle)
def spawn_balle(self,vit):
if self.balle_vie > 0:
self.balle = Balle(self,vit)
self.all_balles.append(self.balle)
