Créer chez vous l'image du vaisseau

• Avec Paint ou Photofiltre, créer le sprite du vaisseau avec fond transparent

• Enregistrer le fichier au format png portant le nom vaisseau.png dans un dossier de vos documents où se trouveront tous les fichiers nécessaires au lancement du programme.

Avec photofiltre : Menu fichier - nouveau,

• choisir une largeur de 31 pixels et une hauteur de 32 pixels. Vérifier que la case transparence automatique est cochée, puis ok.

• Passer en zoom 1200, choisir l'outil pinceau  et la forme petit carré, puis choisir votre couleur. 

Voici une idée simple de vaisseau :

######################################### # Programme écrit par Prénom Nom Classe # # vers. 2023 # ######################################### import pygame,sys from pygame.locals import * pygame.init() pygame.font.init() fenetre_jeu=pygame.display.set_mode((450,560)) # Taille fenêtre du jeu en pixels pygame.display.set_caption('SpaceInvader') # titre de la fenêtre ############################# # Déclaration des variables # ############################# gauche = False droite = False police = pygame.font.Font('SUPERPOI_R.TTF', 10) obj_texte = police.render('les envahisseurs', 0, (255,0,0)) clock = pygame.time.Clock() img_vaisseau = pygame.image.load('vaisseau.png') vitesse_vaisseau=1 rectangle_vaisseau = pygame.Rect(20,500,31,32) ##################################### # Fonction de détection des Touches # ##################################### def detecte_touches(g,d): """ Paramètres : g et d de type booléen Cette fonction permet de détecter les touches enfoncées ou relâchées de quitter le jeu ou de permettre le déplacement du vaisseau retourne un uplet de booléen""" for event in pygame.event.get(): if event.type==QUIT: # Traite l'évènement fermer la fenêtre avec la souris pygame.quit() sys.exit() if event.type== KEYDOWN: # Traiter les évènements du clavier touche enfoncée if event.key==K_ESCAPE: pygame.quit() sys.exit() if event.key==K_RIGHT: d = True if event.key==K_LEFT: g = True if event.type== KEYUP: # Traiter les évènements du clavier touche relâchée if event.key==K_RIGHT: d = False if event.key==K_LEFT: g = False return g,d ##################### # BOUCLE PRINCIPALE # ##################### while True: fenetre_jeu.fill (0x00001A) # Remplir l'arrieère plan avec la couleur RVB Bleu foncé fenetre_jeu.blit(obj_texte,(50,20)) # Placer le texte fenetre_jeu.blit(img_vaisseau,rectangle_vaisseau) # placer l'image gauche,droite=detecte_touches(gauche,droite) # Déplacement du vaisseau d'un ou plusieurs pixels if gauche and rectangle_vaisseau.left > 10 : rectangle_vaisseau.left -= vitesse_vaisseau if droite and rectangle_vaisseau.right < 440 : rectangle_vaisseau.right += vitesse_vaisseau pygame.display.update() # rafraichir l'affichage de la fenêtre jeu clock.tick(30) # Vitesse du jeu : 30 FPS

• Copiez et coller le code ci-dessus dans le logiciel Edupython, puis enregistez le programme dans le répertoire du jeu

• Téléchargez la police par un clic droit sur le lien suivant : Police_Superpoi et "enregistrer la cible du lien sous..." dans le répertoire du jeu

• Téléchargez le vaisseau par un clic droit sur l'image suivante : et "enregistrer la cible du lien sous..." dans le répertoire du jeu

• Votre dossier jeu doit ressembler au suivant :
  
• Accélérer le déplacement du vaisseau en augmentant le pas d'incrémentation de plusieurs pixels.

• Déclarer la variable missiles=list(). Cette varible contiendra une liste des coordonnées des missiles.

• Chaque nouveau missile devra démarrer à la coordonnée x du vaisseau+12 pixels et y du vaisseau.

• Dans la fonction detecte_touches: ajouter l'agorithme permettant d'ajouter les coordonnées du vaisseau dès que la touche espace est enfoncée.

Si la touche espace (K_SPACE) est enfoncée alors
    ajouter à la liste missiles un nouveau missle 

l'ajout d'un missile se fait par la l'instruction : missiles.append(pygame.Rect(rectangle_vaisseau.left+12,rectangle_vaisseau.top,6,16))

• Au-dessus de la boucle principale, ajouter les lignes suivantes :

def deplace_missiles(missiles): """ Paramètres : missile type list contenant les coordonnées des missiles Cette fonction permet de changer les coordonnées des missiles contenu dans la liste missiles cette fonction a un effet de bord sur la liste missiles""" for missile in missiles: # pour chaque missiles existant missile.top=missile.top-10 # soustraire 10 à la coordonnée du point haut pygame.draw.rect(fenetre_jeu,0xFF0000,missile) # dessinner un rectangle de couleur rouge if missile.top<=100: # si le missiles arrive en haut de l'écran missiles.remove(missile) # supprimer le missiles de la liste

• Appeler cette fonction dans la boucle principale While True

• Les coordonnées des aliens seront également représentées par des rectangles, stockés dans une liste nommée aliens.
• Dans la section de déclaration des variables, déclarer la liste vide : aliens=list()
• Importer la librairie random en début de programme : import random.
• Créer la fonction niveau(aliens,n) qui génère une liste aléatoire contenant les coordonnées des rectangles.

def niveau(aliens,n): """paramètre : une liste aliens comprenant les coordonnées des aliens et un entier n représentant le niveau du jeu Cette fonction génère aléatoirement les coordonnées retangulaires des aliens (hitbox) retourne rien""" if n==1: for i in range(100,500,50): aliens.append(pygame.Rect(i,random.randint(100,200),31,24))

• Juste au-dessus la boucle principale, appeler la fonction niveau(aliens,1)
• Implanter la fonction placer_aliens, permettant de dessiner des rectangles aliens

def placer_aliens(aliens): """ paramètre : liste contenant les coordonnées des aliens Cette fonction permet de placer les aliens dans la fenêtre de jeu""" for alien in aliens: pygame.draw.rect(fenetre_jeu,0x00FFFF,alien)

• Appeler cette fonction dans la boucle principale avant l'appel de la fonction deplace_missiles(missiles).
• Ajouter une fonction permettant de détecter les collisions entre les missiles et les aliens.
• La fonction permettant de détecter la collision d'un missile avec un alien se code : missile.colliderect(alien)
• Pour retirer un alien de la liste des aliens : aliens.remove(alien)
• Vous pouvez imaginer comment retirer un missile de la liste des missiles...
• Codez l'algoritme ci-dessous et placez-le avec les autres fonctions.

  déclarer la fonction detecte_collision
  paramètres : missiles (list) et aliens (list)
  retourne rien les listes ont un effet de bord
      pour chaque missile dans la liste des missiles:
          pour chaque alien dans la liste des aliens:
              si le missile est en collision avec un alien: 
                  retirer l'alien de la liste des aliens
                  retirer le missile de la liste des missiles
  

• Appeler la fonction detecte_collision(missiles,aliens) dans la boucle principale avant le placement des aliens dans de la fenêtre jeu.

Il s'agit de placer une image avec la méthode blit en utilisant les coordonnées rectangulaires des aliens.

Les coordonnées x et y vont définir l'emplacement du coin supérieur gauche de l'image, 31 la largeur et 24 la hauteur en pixels de l'image dans la fenêtre de jeu.

Le rectangle bleu est définit par le code pygame.Rect(x,y,31,24)

Les coordonnées des rectangles bleus de chaque alien définissent une "hitbox", pour détecter les colisions entre les missiles et les aliens dans la fonction detecte_collision codée précédemment.

• Enregistrer l'image suivante dans le répertoire courant. (clic droit sur l'image, puis enregistrer l'image sous...)
• Dans la section de déclaration des varibles, charger l'image dans une varible img_aliens. S'inspirer du chargement de l'image du vaisseau.
• Modifier la fonction placer_aliens comme suit :

def placer_aliens(aliens,image): """ Paramètres : aliens (list) image(objet image) de l'alien Cette fonction permet de placer les aliens dans la fenêtre de jeu""" for alien in aliens: fenetre_jeu.blit(image,alien)

• Dans la boucle pricipale modifier l'appel de la fonction placer_aliens(aliens) par placer_aliens(aliens,img_aliens)
• Modifier la fonction niveau(aliens,n) afin de créer 3 rangées de 6 aliens dans le jeu lorsque n=2. Le pas de l'espacement horizontal et vertical est de 50 pixels.

Algorithme :

définir la fonction niveau(aliens,n):
    .... code actuel à garder puis à compléter par : ...
    si n = 2 alors
        pour y variant de 100 à 250 avec un pas de 50
            pour x variant de 75 à 300 avec un pas de 50
                ajouter à la liste des aliens les coordonnées du rectangle (x,y,31,24)



• Avant la boucle principale, remplacer niveau(aliens,1) par niveau(aliens,2)

invader1 :    invader2 :

• Modifier la variable img_aliens dans la section déclaration des variables, afin que img_aliens soit une liste contenant deux images :invader1.png et invader2.png
  img_aliens=[pygame.image.load('invader1.png'),pygame.image.load('invader2.png')]

  On va alterner les images de la liste img_aliens en fonction du temps.

  Dans la boucle principale l'appel de la fonction placer_aliens(aliens,img_aliens) sera remplacée par le code suivant :

  i+=1 placer_aliens(aliens,img_aliens[(i//15)%2]) # Changement d'image toutes les 0.5 secondes si FPS=30

  A chaque tour de boucle (while True) la variable i sera incrémentée 30 fois par secondes (si clock.tick=30). En divisant i par 15 puis en calculant le reste de la division par 2, le résultat sera égal à 0 pendant les 15 premières itérations puis à 1 pendant les 15 itérations suivantes et ainsi de suite. Ce qui permettra d'afficher img_aliens[0] ou img_aliens[1] toutes les 0.5 secondes.

• Déclarer et initialiser la variable i=0 en début de programme, dans la section déclaration des variables.

On peut aussi se poser la question de la valeur maximale que pourra predre i lorsqu'on joue longtemps. Serait-il prudent de la remettre à zéro de temps en temps ou pas ?

Il suffit de changer les coordonnées x pour un déplacement horizontal (alien.left) et y pour un déplacement vertical (alien.top) de chaque rectangle d'alien

• Déclarer une variable vitesse_aliens = 1
  
• Coder l'algorithme suivant :
  

  définir la fonction deplace_aliens
  Paramètres : aliens (list), x (int), y(int)
  permet de déplacer horizontalement(x) ou verticalement (y) les aliens
  
  	pour chaque alien dans la liste des aliens
          ajouter à la coordonnée gauche de l'alien la valeur de x
          ajouter à la coordonnée haute de l'alien la valeur de y 
  

• Appler cette fonction dans la boucle principale avant de placer les aliens : deplace_aliens(aliens,vitesse_aliens,0)

Lorsque l'abscisse les coordonnées d'un alien sera > 440 ou < 10 on change le sens de déplacement des aliens

• Coder l'algorithme suivant :
  

  définir la fonction change_sens_aliens
  paramètres : vitesse, un entier positif ou négatif
  retourne la nouvelle vitesse, un entier positif ou négatif qui dépend de la position des aliens
      pour chaque alien dans la liste des aliens:
          si la coordonnée droite de l'alien > 440 ou si la coordonnée gauche de l'alien < 10
              vitesse=-vitesse
              déplace tous les aliens 0 pixels horizontalement et de 10 pixels vers le bas
              retourne vitesse
      retourne vitesse

• Appeler cette fonction avant la ligne pygame.display.update(), la variable vitesse_aliens sera mise à jour avec le retour de cette fonction

• Déclarer une variables de type liste missiles_aliens=list()
• Déclarer une variable qui définira aléatoirement le temps de tir d'un alien (0.5 secondes à 2 secondes) : tps_tir_alien =  i + random.randint(15,60)
• Dans la boucle principale implanter l'algorithme suiant :
  

  si tps_tir_alien <= i et nombre d'aliens > 0 alors
      tps_tir_alien ←  i + random.randint(15,60)
      ajouter dans la liste des missiles_aliens ce que retourne la fonction ajouter_tir_alien
  

• La fonction ajouter_tir_alien se code de la manière suivante :

def ajouter_tir_alien(aliens): """Paramètres : la liste des coordonnées des aliens non vide retoune les coordonnées d'un tir choisi aléatoirement parmi les aliens restant""" if len(aliens)>0: choix=random.choice(aliens) return pygame.Rect(choix.left+12,choix.bottom,6,16)

• Commenter les lignes du code ci-dessus dans votre porgramme.
• Créer une fonction deplace_missiles_aliens inspirée de deplace_missiles permettant de déplacer les missiles des aliens vers le bas et les supprimer si leur ordonnée y dépasse 500 pixels.

• remplacer le missile par une image
• animer le vaisseau avec 2 images
• compter le score et l'afficher
• détecter les collisions entre le vaisseau et les missibles des aliens
• gérer la fin du jeu (GAME OVER)
• ajouter des niveaux, des aliens à plusieurs vies, un boss, du son avec pygame.mixer, ...

Lorsque votre projet est terminé, compresser votre dossier jeu contenant tous les fichiers : code python + images ...

Attention, ne m'envoyez pas un programme copié sur Internet avec des classes ... ni un programme que vous ne maîtrisez pas. Il faudra le présenter et expliquer le programme à l'oral.