Tuto 4 : gérer des collisions

1. Ajouter des ennemis

Les tirs sont destinés à abattre des ennemis, il faut donc d'abord les créer dans le jeu !

Les images sont affichées à l’écran à raison de 30 frames ( = images ) par seconde ( ceci est modifiable lors de la création de la fenêtre du jeu ).

L’attribut frame_count du module Pyxel comptabilise le nombre d’images affichées depuis le début du jeu.
Ainsi, pour créer un ennemi toutes les secondes par exemple, on vérifie que le nombres d’images est un multiple de 30 :

if pyxel.frame_count % 30 == 0:	# utilisation de l'opérateur modulo = reste de la division 
	....... # création d'un ennemi			
			

La création elle-même des ennemis repose sur le même principe que celui des tirs ( utilisation d'une liste liste_ennemis ), mais on utilise la fonction randint() du module random pour les créer de façon aléatoire selon l’axe des x.

Cette création pourra se faire directement dans la fonction update().

2. Gestion des collisions tir/ennemi

Lorsqu'un des tirs touche un des ennemis, il faut faire disparaître les deux.

Deux problèmes se posent donc :

• il va falloir tester la collision potentielle entre chacun des tirs de la liste liste_tirs et chacun des ennemis de la liste liste_ennemis.
• pour une paire tir/ennemi donnés, comment savoir si ils sont entrés en collision ?

2.1. Algorithme à suivre

pour chaque ennemi dans la liste des ennemis:
	pour chaque tir dans la liste des tirs:
		si ennemi et tir entrent en collision:
			les supprimer tous les deux de leur liste respective
			augmenter ( éventuellement ) le score
			

C'est donc deux boucles imbriquées de parcours de listes qu'il faudra utiliser.

2.2. Détection de la collision

Pour le cas de la collision d’un tir avec un ennemi, trois conditions sur les coordonnées du tir et de l'ennemi doivent être vérifiées simultanément :

• la coordonnée y_tir doit être inférieure ou égale à y_ennemi + 8
• la coordonnée x_tir doit être comprise entre x_ennemi et x_ennemi + 8

2.3. La fonction update() avec le code correspondant à la détection d'une collision tir/ennemi :

def update():

    ....

    for ennemi in liste_ennemis:
        for tir in liste_tirs:
            xt = tir[0]
            yt = tir[1]
            xe = ennemi[0]
            ye = ennemi[1]
            if yt <= ye+8 and ( xt >= xe and xt <= xe + 8):
                liste_tirs.remove(tir)
                liste_ennemis.remove(ennemi)
                score = score + 1
			

3. Gestion des collisions vaisseau/ennemi

Dans ce cas, il suffit de parcourir la liste liste_ennemis, et de détecter la collision entre chacun de ses éléments et le vaisseau ( plus besoin de boucles imbriquées ).

pour chaque ennemi dans la liste des ennemis:
	si ennemi et vaisseau entrent en collision:
		supprimer l'ennemi de la liste des ennemis
		diminuer le nombre de vies de 1
			

Par contre, les conditions à vérifier lorsqu'il y a collisions sont un peu plus délicates, car plusieurs situations peuvent se présenter.

Ne considérons pour l'instant que les conditions à vérifier sur l'axe des x; les deux situations limites pour lesquelles il peut y avoir collision sont :

• dans le premier cas, il y a donc collision si : x_v < x_e + taille ennemi, soit ici x_v < x_e + 8
• dans le deuxième cas : x_v > x_e - taille vaisseau, soit ici x_v > x_e - 8
• la condition à vérifier sur l'axe des x est donc : xe - 8 <= xv <= xe + 8

Par un raisonnement similaire sur l'axe des y, on constaterait qu'il y a collision si : ye - 8 <= yv <= ye + 8

Il y a donc 4 conditions à vérifier simultanément pour détecter une collision entre le vaisseau et un ennemi.

Bien entendu, ces relations sont à adapter au cas où les deux acteurs n'ont pas la même taille...

def draw():

	pyxel.cls(0)
	
	if vies > 0:
		# on affiche les acteurs
		.......
		
	else:
		pyxel.text(50, 64, 'GAME OVER', 7) # affichage au milieu de la fenêtre						
			

4. Ajout des explosions

Raffinement supplémentaire : rajouter des explosions lors de la destruction d'un ennemi.

Ces explosions peuvent être simplement représentées par quelques cercles de rayon croissant ( 5 par exemple dont le rayon va de 1 à 5 pixels ) qui se "propagent" depuis l'ancienne position de l'ennemi.

La gestion des explosions peut se faire sur le même principe que les tirs et les ennemis, à savoir utiliser une liste liste_explosions, dans laquelle on ajoutera/supprimera au besoin des éléments.

Cependant, en plus des coordonnées de "départ" de l'explosion ( qui seront bien entendu égales, lors de la création de l'explosion, au milieu de l'ancienne position de l'ennemi ), il faut prévoir un troisième élément, qui indiquera à quel "stade" l'explosion est, en stockant par exemple son rayon actuel; la valeur de cet élément sera incrémenté à chaque frame, et lorsqu'il sera devenu égal au rayon du plus grand cercle, l'explosion sera supprimée de la liste.

for ennemi in liste_ennemis:
    """ Test des collisions avec les tirs"""
    for tir in liste_tirs:
        x = tir[0]
        y = tir[1]
        xe = ennemi[0]
        ye = ennemi[1]
        if y <= ye+8 and ( x >= xe and x <= xe + 8):
            liste_tirs.remove(tir)
            liste_ennemis.remove(ennemi)
            liste_explosions.append([xe+4, ye+4, 1]) # ajout d'une explosion à la liste ( rayon initial = 1 pixel )
            score = score + 1

    """Tests des collisions avec le vaisseau"""
    if vaisseau_x < ennemi[0] + 8 and vaisseau_x > ennemi[0] - 8 and vaisseau_y < ennemi[1] + 8 and vaisseau_y > ennemi[1] - 8:
        liste_ennemis.remove(ennemi)
        liste_explosions.append([xe+4, ye+4, 1]) 	# ajout d'une explosion à la liste
        vies = vies - 1