Aller au contenu

TP⚓︎

Objectifs:⚓︎

  • Se familiariser avec une bibliothèque graphique
  • Travailler sur le concept de fonctions

NE PAS OUBLIER LE COMPTE RENDU : 1NSINF1, 1NSINF2

1. Davistk⚓︎

Ce TP utilise le module de dessin davistk que vous devez télécharger et placer dans le même dossier que les programmes que vous allez écrire. Pour pouvoir l'utiliser dans un programme, vous devez charger les fonctions de ce module en écrivant la ligne from davistk import en début de fichier. La documentation du module se trouve là: davistk.brunache.ovh Ce TP vous permettra de manipuler les fonctions du module de dessin et leurs arguments.

  1. Copier le code ci-dessous dans un fichier et l'exécuter:

    from davistk import * # Importe les fonctions du module davistk

cree_fenetre(600,600) # Crée un fenetre de 600 par 600

rectangle(10,10,100,50) # Crée un rectangle
rectangle(200,100,300,150) # Crée un autre rectangle

attend_ev() # Attend un evenement (clic, touche clavier...)
ferme_fenetre() # ferme la fenêtre

  2. Dans un nouveau fichier

    1. Créer une fenêtre de 400 par 400
    2. Dessiner un cercle de rayon 100 centré au milieu de la fenêtre
    3. Dessiner un cercle rouge de rayon 100 légèrement à gauche du premier cercle.

2. Une balle rebondissante⚓︎

Récupérer le fichier suivant, le mettre dans le même dossier que celui utilisé jusqu'ici.

  1. Copier le code suivant dans un nouveau fichier et l'éxécuter:

    from balle import *

def mise_a_jour_vitesse(dx, dy, ax, ay):
    return dx, dy # A modifier

def mise_a_jour_position(x, y, dx, dy):
    return x, y # A modifier

def affiche_balle(x, y, taille):
    ... # A modifier

x, y = 100, 50 # Position initiale de la balle
taille = 10 # Rayon de la balle
dx, dy = 1, 1 # Vitesse initiale de la balle à chaque rafraichissement la balle se déplace de dx et de dy
cree_fenetre(400, 400) 
encore = True # Booléen permettant d'arrêter lorsqu'on appuie sur l'icone pour fermer la fenêtre
while encore: # Boucle (on verra ca plus tard) permettant de répéter les actions indentées ci-dessous à chaque rafraichissement d'image
    ax, ay, encore = gestion_evenement() # permet de récupérer les touches claviers et les clics
    dx, dy = mise_a_jour_vitesse(dx, dy, ax, ay) # permet de calculer la nouvelle vitesse en fonction de l'accélération demandée par le joueur
    x, y = mise_a_jour_position(x, y, dx, dy) # permet de calculer la nouvelle position de la balle en fonction de sa vitesse
    x, y, dx, dy = gestion_collision(x, y, dx, dy, taille) # Permet de gérer les collisions avec les murs
    affiche_balle(x, y, taille) # Affiche la balle
ferme_fenetre() # ferme la fenêtre lorque l'on clique sur l'icone pour fermer la fenetre

    On donne ci-dessous les docstrings et doctests des fonctions gestion_evenement et gestion_collision

    def gestion_evenement():
    """Cette fonction permet de récupérer les informations du joueur tels que les touches pressées et le clic sur l'icone fermer.
    Si le joueur presse une touche de direction (droite, gauche, haut, bas) la fonction retourne le changement de vitesse à réaliser.
    Exemple: 
        - si il presse à gauche, cela signifie que la vitesse horizontale diminue (en l'occurence, elle diminuera de 1), la fonction renvoie donc:  -1, 0, True (le dernier étant le fait de continuer le jeu)
        - si il presse en bas, cela signifie que la vitesse verticale augmente (en l'occurence, elle augmentera de 1), la fonction renvoie alors: 0, 1, True
    Si le joueur clique sur l'icone pour fermer la fenetre, la fonction renvoie 0, 0, False (ce dernier servant à arreter le jeu)"""

def gestion_collision(x, y, dx, dy, taille):
    """Cette fonction gère les collisions de la balle avec les murs, si la balle touche un mur sa vitesse est modifiée suivant la règle suivante:
        - Si elle touche un mur de droite ou de gauche, la vitesse verticale n'est pas modifiée mais la vitesse horizontale est opposée.
        - Si elle touche un mur de haut ou de bas, la vitesse horizontale n'est pas modifiée mais la vitesse verticale est opposée.
    Pour éviter des problème de 'traversée' de mur on remet la balle exactement sur le mur.
    Attention le fait de toucher le mur dépend de la position de la balle et de sa taille.

    >>> gestion collision(100, 391, 2, 3, 10) # touche en bas
    (100, 390, 2, -3) # la balle remonte alors
    """

  2. Pourquoi rien ne s'affiche-t-il ?

  3. Compléter la fonction affiche_balle sachant que l'on représentera la balle par un cercle de rayon taille. Tester.

  4. Compléter la fonction mise_a_jour_position de manière à ce qu'elle réponde au docstring et doctests suivant:

    def mise_a_jour_position(x, y, dx, dy):
    """Cette fonction renvoie la nouvelle position de la balle en fonction de sa positoin précédente et de sa vitesse.

    Exemple:

    >>> mise_a_jour_position(120, 133, -3, 4)
    (117, 137)
    """

    Retester.

  5. Compléter la fonction mise_a_jour_vitesse de manière à ce qu'elle réponde au docstring et doctests suivant:

    def mise_a_jour_vitesse(dx, dy, ax, ay):
    """Cette fonction renvoie la nouvelle vitesse de la balle en fonction de sa vitesse précédente et de son changement de vitesse.

    Exemple:

    >>> mise_a_jour_vitesse(2, -3, 1, -2)
    (3, -5)
    """

    Retester.

  6. Modifier la couleur de la balle.

  7. La pesanteur est une accélération (un changement de vitesse) constament vers le bas, simuler cette accélération dans votre jeu.

3. ⭐ Calculer avec des fractions⚓︎

Dans cet exercice, on manipulera des fractions à l'aide de couples d'entiers. Par exemple, la fraction \(\frac{a}{b}\) sera représentée par le couple \((a, b)\), qui s'écrit également en Python (a, b), ou même parfois simplement a, b.

Par exemple, pour initialiser une fraction f à la valeur \(\frac{3}{4}\), on écrira : f = (3, 4). Réciproquement, pour récupérer les valeurs du numérateur et du dénominateur de f dans deux variables a et b, on écrira : (a, b) = f. On reviendra sur ce type de valeurs plus tard dans le cours.

  1. Écrire une fonction valeur_approchee(f) recevant une fraction et renvoyant sa valeur approchée sous forme de float.
  2. Écrire une fonction simplifier(f) recevant une fraction et en renvoyant une forme simplifiée. On utilisera la fonction gcd du module math.
  3. Écrire une fonction oppose(f) recevant une fraction et renvoyant son opposé.
  4. Écrire une fonction inverse(f) recevant une fraction et renvoyant son inverse.
  5. Écrire une fonction multiplier(f, g) recevant comme paramètres deux fractions f et g et renvoyant leur produit, et une fonction diviser(f, g) renvoyant leur quotient. Cette dernière fonction devra utiliser la fonction multiplier.
  6. ⭐ Écrire une fonction additionner(f, g) recevant comme paramètres deux fractions f et g et renvoyant leur somme, et une fonction soustraire(f, g) renvoyant leur différence. Cette dernière fonction devra utiliser la fonction additionner.
  7. Modifier (si nécessaire) toutes les fonctions précédentes afin qu'elles renvoient toujours des fractions irréductibles (c'est-à-dire sous forme simplifiée).