def test_collision_trop_haut():
vaisseau = Vaisseau(50, 480)
bille = Bille(50, 480 - 50, 640)
bille.forme.y = vaisseau.forme.y + vaisseau.forme.height + 2 * bille.forme.radius
bille.forme.x = vaisseau.forme.x + vaisseau.forme.width // 2
assert not vaisseau.collision(bille)
def test_collision():
vaisseau = Vaisseau(50, 480)
bille = Bille(50, 480 - 50, 640)
bille.forme.y = vaisseau.forme.y + vaisseau.forme.height // 2
bille.forme.x = vaisseau.forme.x + vaisseau.forme.width // 2
assert vaisseau.collision(bille)
def test_bouge_depasse_taille():
vaisseau = Vaisseau(50, 480)
vaisseau.forme.x = 479 - LONGUEUR
vaisseau.vitesse = 10
vaisseau.bouge(1, +1)
assert vaisseau.forme.x == 480 - LONGUEUR
def test_collision_trop_droite():
vaisseau = Vaisseau(50, 480)
bille = Bille(50, 480 - 50, 640)
bille.forme.y = vaisseau.forme.y + vaisseau.forme.height // 2
bille.forme.x = vaisseau.forme.x + vaisseau.forme.width + 2 * bille.forme.radius
assert not vaisseau.collision(bille)
def test_bouge_negatif():
vaisseau = Vaisseau(50, 480)
vaisseau.forme.x = 1
vaisseau.vitesse = 10
vaisseau.bouge(1, -1)
assert vaisseau.forme.x == 0
def test_bouge_droite():
vaisseau = Vaisseau(50, 480)
vaisseau.forme.x = 0
vaisseau.vitesse = 10
vaisseau.bouge(2, +1)
assert vaisseau.forme.x == 20
def test_bouge_gauche():
vaisseau = Vaisseau(50, 480)
vaisseau.forme.x = 100
vaisseau.vitesse = 10
vaisseau.bouge(2, -1)
assert vaisseau.forme.x == 80
def __init__(self):
"""Initialisation"""
pygame.init()
self.parametres = Parametres()
self.ecran = pygame.display.set_mode(
(self.parametres.largeur,
self.parametres.hauteur)) #Créer une fenêtre
pygame.display.set_caption("Invaders")
self.stats = Stats(self)
self.scoreboard = Scoreboard(self)
"""Jeu en plein écran
self.ecran = pygame.display.set_mode((0,0), pygame.FULLSCREEN)
self.parametres.largeur = self.ecran.get_rect().width
self.parametres.largeur = self.ecran.get_rect().height"""
self.vaisseau = Vaisseau(self)
self.bullets = pygame.sprite.Group()
self.aliens = pygame.sprite.Group()
self._create_fleet()
self.play_bouton = Bouton(self, "Play")
def __init__(self):
super().__init__(640, 480, "Arkanoid")
self.score = pyglet.text.Label(
"0",
x=630,
y=470,
anchor_x="right",
anchor_y="top",
)
self.vie = pyglet.text.Label(
"2",
x=10,
y=10,
anchor_x="left",
anchor_y="bottom",
)
self.sol = pyglet.shapes.Line(0, 50, 640, 50, color=(0xFF, 0xFF, 0xFF))
self.plafond = pyglet.shapes.Line(0,
480 - 50,
640,
480 - 50,
color=(0xFF, 0xFF, 0xFF))
self.vaisseau = Vaisseau(50, 640)
self.bille = Bille(50, 480 - 50, 640)
self.bille.vitesse = (75, 25)
self.briques = []
for i in range(12):
for j in range(5):
self.briques.append(Brique(25 + i * (40 + 10), 400 - j * 30))
self.direction = 0 # -1 (gauche) ; 0 (immobile) ; 1 (droite)
pyglet.clock.schedule_interval(self.update, 1 / 60)
def test_position_initiale():
vaisseau = Vaisseau(50, 480)
assert vaisseau.forme.x == (480 - LONGUEUR) // 2
assert vaisseau.forme.y == 50
class Fenetre(pyglet.window.Window):
def __init__(self):
super().__init__(640, 480, "Arkanoid")
self.score = pyglet.text.Label(
"0",
x=630,
y=470,
anchor_x="right",
anchor_y="top",
)
self.vie = pyglet.text.Label(
"2",
x=10,
y=10,
anchor_x="left",
anchor_y="bottom",
)
self.sol = pyglet.shapes.Line(0, 50, 640, 50, color=(0xFF, 0xFF, 0xFF))
self.plafond = pyglet.shapes.Line(0,
480 - 50,
640,
480 - 50,
color=(0xFF, 0xFF, 0xFF))
self.vaisseau = Vaisseau(50, 640)
self.bille = Bille(50, 480 - 50, 640)
self.bille.vitesse = (75, 25)
self.briques = []
for i in range(12):
for j in range(5):
self.briques.append(Brique(25 + i * (40 + 10), 400 - j * 30))
self.direction = 0 # -1 (gauche) ; 0 (immobile) ; 1 (droite)
pyglet.clock.schedule_interval(self.update, 1 / 60)
def update(self, dt):
self.vaisseau.bouge(dt, self.direction)
self.bille.bouge(dt)
if self.vaisseau.collision(self.bille):
self.score.text = str(int(self.score.text) + 1)
self.bille.vitesse = (self.bille.vitesse[0],
-self.bille.vitesse[1])
for brique in self.briques:
if brique.collision(self.bille):
self.score.text = str(int(self.score.text) + 5)
self.bille.vitesse = (self.bille.vitesse[0],
-self.bille.vitesse[1])
self.briques.remove(brique)
if self.bille.vitesse == (0, 0):
vie = int(self.vie.text)
if vie > 0:
vie -= 1
self.vie.text = str(vie)
self.bille.vitesse = (75, 25)
def on_key_press(self, symbol, modifiers):
if symbol == key.LEFT:
self.direction += -1
elif symbol == key.RIGHT:
self.direction += 1
def on_key_release(self, symbol, modifiers):
if symbol == key.LEFT:
self.direction -= -1
elif symbol == key.RIGHT:
self.direction -= 1
def on_draw(self):
self.clear()
self.score.draw()
self.vie.draw()
self.sol.draw()
self.plafond.draw()
self.vaisseau.draw()
self.bille.draw()
for brique in self.briques:
brique.draw()
def jouer(n, carte):
missionss = Mission((carte[0][0], carte[0][1]), (carte[1][0], carte[1][1]),
carte[2], carte[3], carte[4], carte[5], carte[6])
vaisseau = Vaisseau(Vector(missionss.jx, missionss.jy), missionss.vitax,
missionss.energie)
window = pyglet.window.Window(700, 700)
kitten = pyglet.image.load('pilote.png')
kitten.anchor_x = kitten.width // 2
kitten.anchor_y = kitten.height // 2
poten = pyglet.sprite.Sprite(kitten, x=missionss.jx, y=missionss.jy)
croix = pyglet.image.load('trou35.png')
croix.anchor_x = croix.width // 2
croix.anchor_y = croix.height // 2
croixx = pyglet.sprite.Sprite(croix, x=missionss.fx, y=missionss.fy)
fond = pyglet.image.load('fond.jpg')
fonds = pyglet.sprite.Sprite(fond, x=0, y=0)
liste_joueurs = []
for i in range(
0, n - 1
): # boucle qui génère une liste avec les sprites des différents joueurs
beta = pyglet.image.load('pilote2.png')
beta.anchor_x = beta.width // 2
beta.anchor_y = beta.height // 2
liste_joueurs.append(
pyglet.sprite.Sprite(beta, x=missionss.jx, y=missionss.jy))
keys = key.KeyStateHandler()
window.push_handlers(keys)
delta_r = Chrono(autostart=True) # création du chrono
@window.event
def on_draw():
window.clear()
fonds.draw()
for vecteurs in range(0, len(missionss.listpol)):
vertex = missionss.listpol[vecteurs]
for i in polytri.triangulate(vertex):
pyglet.graphics.draw(
3, pyglet.gl.GL_POLYGON,
('v2i',
(i[0][0], i[0][1], i[1][0], i[1][1], i[2][0], i[2][1])),
('c3B', (255, 0, 0, 0, 255, 0, 0, 0, 255)))
croixx.draw()
poten.draw()
for autres_joueurs in liste_joueurs:
autres_joueurs.draw(
) # affiche les différents sprites des joueurs à l'écran
croixx.draw()
if delta_r.get() > 0.025:
# ok, le délai minimum est respecté,
# rapporter l'état puis mettre à zéro le chrono
états = client.rapporter((vaisseau.po.x, vaisseau.po.y),
(vaisseau.vitesse.x, vaisseau.vitesse.y),
vaisseau.angle)
if états is not None:
fin_jeu = états.copy()
fin_jeu.pop('gagnant')
for pseudo in états.keys():
if états[pseudo] is None:
continue
score_label = pyglet.text.Label(text=pseudo,
x=états[pseudo][0][0],
y=états[pseudo][0][1])
score_label.draw()
fin_jeu.pop(client.pseudonyme)
b = 0
# Si la méthode "rapporter" renvoie un dictionnaire avec les positions et les angles des joueurs,
# on génère une boucle, et on itère sur chaque clé pour pouvoir associer ces coordonnées aux
# coordonnées des sprites des joueurs
for adversaire in fin_jeu.values():
if adversaire is None:
continue
liste_joueurs[b].x, liste_joueurs[b].y = adversaire[0][
0], adversaire[0][1]
liste_joueurs[b].rotation = adversaire[2]
b += 1
if états['gagnant'] is not None:
a = "Le gagnant est: "
a += "{}, ".format(états["gagnant"])
print(a) # affiche le ou les gagnants
exit() # quitte le jeu
delta_r.reset() # mettre à zéro le chrono
def update(dt):
if keys[key.LEFT]:
vaisseau.angle -= missionss.ang * dt
if keys[key.RIGHT]:
vaisseau.angle += missionss.ang * dt
if keys[key.UP]:
vaisseau.acc(dt)
vaisseau.move(dt)
# détecte si il y a collision avec les 4 bords de la fenêtre
obstacle = Obstacle(vaisseau.po, vaisseau.vitesse, missionss.elas)
obstacle.detecter_collision(dt, Vector(700, 0), Vector(700, 700))
obstacle.detecter_collision(dt, Vector(0, 0), Vector(0, 700))
obstacle.detecter_collision(dt, Vector(0, 700), Vector(700, 700))
obstacle.detecter_collision(dt, Vector(0, 0), Vector(700, 0))
# détecte si il y a collision avec les différents obstacles du jeu
for i in range(0, len(missionss.listpol)):
for j in range(0, len(missionss.listpol[i])):
if j == (len(missionss.listpol[i]) - 1):
obstacle.detecter_collision(
dt,
Vector(missionss.listpol[i][j][0],
missionss.listpol[i][j][1]),
Vector(missionss.listpol[i][0][0],
missionss.listpol[i][0][1]))
else:
obstacle.detecter_collision(
dt,
Vector(missionss.listpol[i][j][0],
missionss.listpol[i][j][1]),
Vector(missionss.listpol[i][j + 1][0],
missionss.listpol[i][j + 1][1]))
vaisseau.po.x, vaisseau.po.y = obstacle.p.x, obstacle.p.y
vaisseau.vitesse.x, vaisseau.vitesse.y = obstacle.v.x, obstacle.v.y
# associe les positions et angles de l'objet vaisseau au sprite du joueur
poten.x, poten.y = vaisseau.po.x, vaisseau.po.y
poten.rotation = vaisseau.angle
pyglet.clock.schedule_interval(update, 1 / 60)
pyglet.app.run()
class Invaders:
def __init__(self):
"""Initialisation"""
pygame.init()
self.parametres = Parametres()
self.ecran = pygame.display.set_mode(
(self.parametres.largeur,
self.parametres.hauteur)) #Créer une fenêtre
pygame.display.set_caption("Invaders")
self.stats = Stats(self)
self.scoreboard = Scoreboard(self)
"""Jeu en plein écran
self.ecran = pygame.display.set_mode((0,0), pygame.FULLSCREEN)
self.parametres.largeur = self.ecran.get_rect().width
self.parametres.largeur = self.ecran.get_rect().height"""
self.vaisseau = Vaisseau(self)
self.bullets = pygame.sprite.Group()
self.aliens = pygame.sprite.Group()
self._create_fleet()
self.play_bouton = Bouton(self, "Play")
def run_game(self):
while True:
self._check_events()
if self.stats.game_active:
self.vaisseau.update()
self._update_bullets()
self._update_aliens()
self._update_ecran()
def _update_aliens(self):
self._check_fleet_edges()
self.aliens.update()
if pygame.sprite.spritecollideany(self.vaisseau, self.aliens):
self._impact()
self._check_aliens_bottom()
def _check_events(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
elif event.type == pygame.KEYDOWN:
self._check_keydown(event)
elif event.type == pygame.KEYUP:
self._check_keyup(event)
elif event.type == pygame.MOUSEBUTTONDOWN:
mouse_pos = pygame.mouse.get_pos()
self._check_play_button(mouse_pos)
def _check_play_button(self, mouse_pos):
button_clicked = self.play_bouton.rect.collidepoint(mouse_pos)
if button_clicked and not self.stats.game_active:
self.parametres.initialize_dynamic_settings()
self.stats.reset_stats()
self.stats.game_active = True
self.scoreboard.prep_score()
self.aliens.empty()
self.bullets.empty()
self._create_fleet()
self.vaisseau.centrer_vaisseau()
pygame.mouse.set_visible(False)
def _check_keydown(self, event):
if event.key == pygame.K_RIGHT:
self.vaisseau.mouvement_droite = True
elif event.key == pygame.K_LEFT:
self.vaisseau.mouvement_gauche = True
elif event.key == pygame.K_a: #Il faut appuyer sur Q si clavier AZERTY
sys.exit()
elif event.key == pygame.K_SPACE:
self._fire_bullet()
def _check_keyup(self, event):
if event.key == pygame.K_RIGHT:
self.vaisseau.mouvement_droite = False
elif event.key == pygame.K_LEFT:
self.vaisseau.mouvement_gauche = False
def _update_bullets(self):
for bullet in self.bullets.copy():
if bullet.rect.bottom <= 0:
self.bullets.remove(bullet)
#print(len(self.bullets))
self._check_bullet_alien_collision()
self.bullets.update()
def _check_bullet_alien_collision(self):
collisions = pygame.sprite.groupcollide(
self.bullets, self.aliens, True,
True) # True True : Supprimer balles et aliens
if collisions:
for aliens in collisions.values():
self.stats.score += self.parametres.score_alien
self.scoreboard.prep_score()
self.scoreboard.check_high_score()
if not self.aliens:
self.bullets.empty()
self._create_fleet()
self.parametres.inicrease_speed()
def _update_ecran(self):
self.ecran.fill(self.parametres.fond)
self.vaisseau.blitme()
for bullet in self.bullets.sprites():
bullet.draw_bullet()
self.aliens.draw(self.ecran)
self.scoreboard.show_score()
if not self.stats.game_active:
self.play_bouton.draw_bouton()
pygame.display.flip(
) #Laisser flip à la fin pour update l'écran en dernier !
def _create_fleet(self):
alien = Alien(self)
alien_width, alien_height = alien.rect.size
available_space_x = self.parametres.largeur - (2 * alien_width)
number_aliens_x = available_space_x // (2 * alien_width)
hauteur_vaisseau = self.vaisseau.rect.height
available_space_y = (self.parametres.hauteur - (3 * alien_height) -
hauteur_vaisseau)
nb_lignes = available_space_y // (2 * alien_height)
for row_number in range(nb_lignes):
for alien_number in range(number_aliens_x):
self._create_alien(alien_number, row_number)
def _create_alien(self, nb_aliens, nb_lignes):
alien = Alien(self)
alien_width, alien_height = alien.rect.size
alien.x = alien_width + 2 * alien_width * nb_aliens
alien.rect.x = alien.x
alien.rect.y = alien.rect.height + 2 * alien.rect.height * nb_lignes
self.aliens.add(alien)
def _fire_bullet(self):
if len(self.bullets) < self.parametres.balles_max:
new_Bullet = Bullet(self)
self.bullets.add(new_Bullet)
def _check_fleet_edges(self):
for alien in self.aliens.sprites():
if alien.check_bords():
self._change_direction()
break
def _change_direction(self):
for alien in self.aliens.sprites():
alien.rect.y += self.parametres.flotte_vitesse
self.parametres.flotte_direction *= -1
def _impact(self):
if self.stats.vies > 0:
self.stats.vies -= 1
self.aliens.empty()
self.bullets.empty()
self._create_fleet()
self.vaisseau.centrer_vaisseau()
else:
self.stats.game_active = False
pygame.mouse.set_visible(True)
sleep(0.5)
def _check_aliens_bottom(self):
ecran_rect = self.ecran.get_rect()
for alien in self.aliens.sprites():
if alien.rect.bottom >= ecran_rect.bottom:
self._impact()