Voici un exercice prêt à l’emploi destiné aux élèves du secondaire math-sciences, permettant de coder en Python un calculateur simple de trajectoire d’un projectile. Cet exercice met en pratique les compétences en physique, mathématiques et programmation.

Exercice : Calcul de la trajectoire d'un projectile avec Python et Pygame

Objectif 🎯

À la fin de cet exercice, tu seras capable :

• D’utiliser des formules de physique pour calculer la trajectoire d'un projectile.
• D'intégrer une fonction mathématique dans un jeu codé en Python.
• De visualiser le résultat de ton calcul grâce à la bibliothèque Pygame.

Rappels théoriques 📚

Formules essentielles à connaître

Pour calculer la trajectoire d’un projectile (ex. : un boulet de canon), on utilise les formules suivantes issues de la physique du mouvement :

• Décomposition de la vitesse initiale :

  Quand tu lances un projectile à une vitesse initiale ( v ), avec un angle de lancement ( \alpha ) :

[ v_x = v \cdot \cos(\alpha) \quad;\quad v_y = v \cdot \sin(\alpha) ]

• Position en fonction du temps :

  La position du projectile à l'instant ( t ) avec une gravité ( g ) est donnée par :

[ x(t) = v_x \cdot t ]

[ y(t) = v_y \cdot t - \frac{1}{2} g \cdot t^2 ]

Où :

• ( v ) est la vitesse initiale (en m/s),
• ( \alpha ) l’angle (en radians),
• ( g ) la gravité (généralement (9.81, m/s^2)),
• ( t ) le temps écoulé depuis le lancement (en secondes).

Ton défi : Complète la fonction de calcul 🚀

Voici le squelette du programme de jeu. À toi de coder la fonction calcul_trajectoire en utilisant les formules ci-dessus !

Squelette du programme Python (avec Pygame)

import pygame
import math

# Paramètres du jeu
LARGEUR, HAUTEUR = 1900, 1000
FPS = 60
GRAVITE = 9.81

pygame.init()
fenetre = pygame.display.set_mode((LARGEUR, HAUTEUR))
pygame.display.set_caption("Simulation de trajectoire")
clock = pygame.time.Clock()


projectile_en_vol = True

def calcul_trajectoire(angle, vitesse, gravite, temps):
    """
    Calcule la position (x,y) du projectile à l'instant 'temps'.
    Angle en degrés, vitesse en m/s, gravité en m/s², temps en s.
    Retourne un tuple (x, y).
    """
    # IMPLÉMENTE LE CODE

    return x, y

# Boucle principale du jeu
def main():
    running = True
    temps = 0
    angle = 70     # Angle de lancement en degrés
    vitesse = 150   # Vitesse initiale en m/s

    trajectoire = []  # Liste des points calculés
    projectile_en_vol = True
    
    # Configuration de la police pour afficher les informations
    font = pygame.font.SysFont("Arial", 18)
    
    while running:
        clock.tick(FPS)

        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False

        # Calcule la trajectoire point par point toutes les 0.1 secondes
        if projectile_en_vol:
            x, y = calcul_trajectoire(angle, vitesse, GRAVITE, temps)
            
            # Conversion coordonnées réelles vers coordonnées pygame (inverse y)
            if y >= 0:
                pygame_x = int(x)
                pygame_y = int(HAUTEUR - y)
                trajectoire.append((pygame_x, pygame_y))
                temps += 0.05
            else:
                projectile_en_vol = False
        # Affichage
        fenetre.fill((255, 255, 255))  # fond blanc

        # Dessiner la trajectoire
        for point in trajectoire:
            pygame.draw.circle(fenetre, (255, 0, 0), point, 3)

        # Afficher vitesse, altitude, temps en haut à droite
        infos = [
            f"Vitesse initiale : {vitesse:.1f} m/s",
            f"Altitude : {max(0, y):.1f} m",
            f"Temps écoulé : {temps:.1f} s"
        ]

        # Affichage des infos avec un léger espacement vertical
        for i, texte in enumerate(infos):
            surface_texte = font.render(texte, True, (0, 0, 0))
            largeur_texte, hauteur_texte = surface_texte.get_size()
            fenetre.blit(surface_texte, (LARGEUR - largeur_texte - 10, 10 + i * (hauteur_texte + 5)))

        pygame.display.flip()

    pygame.quit()

if __name__ == "__main__":
    main()

Instructions détaillées pour la fonction 🧑‍💻

Pour compléter calcul_trajectoire, tu dois :

1. Convertir l’angle donné (en degrés) en radians à l’aide de math.radians(angle).
2. Décomposer la vitesse en composantes horizontale (v_x) et verticale (v_y).
3. Calculer les coordonnées x et y à l’aide des formules données.
4. Retourner (x, y).

Astuce : Teste d’abord ta fonction avec des valeurs simples pour vérifier qu'elle fonctionne correctement.

Exemple de résultat attendu 🎮

Si tu utilises les valeurs :

• angle = 45°
• vitesse = 50 m/s
• gravité = 9.81 m/s²

Tu devrais observer à l'écran une courbe représentant la trajectoire du projectile (en forme de parabole).

Synthèse : ce qu'il faut retenir 📌

• La trajectoire d’un projectile est déterminée par deux composantes distinctes de mouvement (horizontal et vertical).
• Les positions sont calculées en utilisant des fonctions trigonométriques (sin, cos) et des équations de physique.
• Le temps permet d’animer le déplacement en calculant successivement les positions du projectile.
• Toujours valider tes résultats intermédiaires pour éviter les erreurs.

À toi de jouer ! Bonne programmation ! 🐍🚀