كيفية إنشاء نافذة PYGAME ؟

Variateur( potentiomètre) de lumière avec Arduino.

 

Pièces nécessaires

• Carte Arduino

• Plaque d'expérimentation

•jumper

• LED

•variateur 50 kOhms

• Résistance 470 ohms

variateur est une résistance variable dotée d'un bouton permettant de modifier sa résistance en le tournant. Il est couramment utilisé dans les appareils électriques, comme les commandes de volume des équipements audio. Ce projet utilise un potentiomètre de 50 kOhms.

https://solutionmeca.blogspot.com/2025/02/arduinopieces-dans-votre-kit.html

https://solutionmeca.blogspot.com/2025/02/cours-2-arduinopieces-dans-votre-kit.html

Fonctionnement

variateur  manipule un signal analogique continu, qui représente des mesures physiques. L'être humain perçoit le monde de manière analogique ; tout ce que nous voyons et entendons est une transmission continue d'informations à nos sens. Ce flux continu définit les données analogiques. Les informations numériques, quant à elles, estiment les données analogiques à l'aide de simples nombres. Pour approximer les données analogiques continues du potentiomètre, l'Arduino doit représenter le signal sous la forme d'une série de nombres discrets, en l'occurrence des tensions. La broche centrale du potentiomètre envoie le signal à une entrée analogique de l'Arduino (n'importe quelle broche comprise entre A0 et A5) pour en lire la valeur.

La LED s'allume et s'éteint, mais si rapidement que nos yeux compensent et nous voyons une LED allumée en continu

à différents niveaux de luminosité. C'est ce qu'on appelle la persistance rétinienne.

Pour créer la persistance rétinienne, l'Arduino utilise une technique appelée modulation de largeur d'impulsion (MLI). L'Arduino crée une impulsion en allumant et en éteignant l'alimentation très rapidement. La durée d'activation ou de désactivation (appelée largeur d'impulsion) du cycle détermine la sortie moyenne. En faisant varier cette largeur d'impulsion, le modèle peut simuler des tensions comprises entre 5 volts et 0 volts. Si le signal de l'Arduino est activé la moitié du temps et désactivé l'autre moitié, la sortie moyenne sera de 2,5 volts, à mi-chemin entre 0 et 5. Si le signal est activé pendant 80 % et désactivé pendant 20 %, la tension moyenne est de 4 volts, et ainsi de suite. Vous pouvez faire varier le signal, ce qui modifie à son tour la largeur d'impulsion, en tournant le potentiomètre vers la gauche ou la droite, augmentant ou diminuant la résistance. Cette technique permet de modifier la tension envoyée à la LED et de l'augmenter ou de la diminuer pour correspondre au signal analogique du potentiomètre. Seules les broches 3, 5, 6, 9, 10 ou 11 de l'Arduino peuvent utiliser la modulation de largeur d'impulsion (PWM). 

Modulation de largeur d'impulsion(PWM)

Signal élevé (à 5 volts) pendant 20 % du temps et signal bas (à 0 volt) pendant 80 % du temps. La sortie (ligne rouge) sera donc de 0,2 × 5 V = 1 V.

Signal élevé pour 50 % et bas pour 50 %, donc la sortie sera de 0,5 × 5 V = 2,5 V

Signal élevé pour 80 % et faible pour 20 %, donc la sortie sera de 0,8 × 5 V = 4 V.

Montage

1. Insérez le variateur dans votre platine d'expérimentation et connectez la broche centrale à la broche A0 de l'Arduino. Connectez l'une des broches extérieures au rail +5 V de la platine d'expérimentation et l'autre à la masse (GND) de la platine (le sens de connexion des broches extérieures du potentiomètre n'a pas d'importance ; ces instructions ne font que reproduire les schémas de ce projet)

Connecter le potentiomètre à l'Arduino.

2. Insérez la LED dans la plaque d'essai. Connectez la patte positive (la plus longue) à la broche 9 de l'Arduino via la résistance de 470 ohms, et la patte négative à la masse (GND).

3. Téléchargez le code dans « Le croquis » ci-dessous.

4. Tournez le potentiomètre pour contrôler la luminosité de la LED.

Ce projet offre de nombreuses possibilités : vous pouvez regrouper plusieurs LED pour créer une lampe de poche réglable, une veilleuse, un éclairage de vitrine ou tout autre éclairage à intensité variable.

Le schéma

Ce schéma fonctionne en définissant la broche A0 comme VARIATEUR et la broche 9 comme sortie pour alimenter la LED. Vous exécutez ensuite une boucle qui lit en continu la valeur du VARAITEUR et l'envoie sous forme de tension à la LED. La tension est comprise entre 0 et 5 volts, et la luminosité de la LED varie en conséquence.

Le code.

int potPin = A0; 

int potValue = 0; 

int led = 9; 

void setup() {

pinMode(led, OUTPUT);

void loop() {

potValue = analogRead(potPin);

analogWrite(led, potValue/4); 

delay(10);

}

contrôlée LED par bouton-poussoir.

Pièces requises

 • Arduino 

• plaque d'essaie

• Jumper 

• LED

• Button _ poussoir

•  résistance 10k-ohm 

•  résistance 220-ohm résistor

Fonctionnement

Lorsqu'on appuie sur un bouton-poussoir, un circuit est fermé et activé.

Dès qu'on relâche le bouton, la connexion revient et coupe le circuit. L'interrupteur à bouton-poussoir est également appelé interrupteur momentané ou normalement ouvert et est utilisé, par exemple, sur les claviers d'ordinateur. Il diffère de l'interrupteur à bascule, qui reste allumé ou éteint jusqu'à ce qu'on le bascule dans l'autre position, comme un interrupteur d'éclairage.

Ce type de bouton-poussoir possède quatre broches, mais on n'en utilise généralement que deux à la fois pour la connexion. Dans ce projet, on utilisera les connexions du haut, bien que les deux broches inutilisées du bas remplissent la même fonction.  les broches fonctionnent dans un circuit. Les broches A et C sont toujours connectées, tout comme les broches B et D. Lorsque le bouton est enfoncé, le circuit est fermé.

La construction

1- Placez votre bouton-poussoir sur une plaque d'essai.

2-Connectez la broche A à une patte d'une résistance de 10 kOhms, puis cette même patte à la broche 2 de l'Arduino. 

Connectez l'autre patte de la résistance au rail GND, puis ce rail GND au rail GND de l'Arduino. Connectez la broche B de l'interrupteur au rail +5 V, puis ce rail au +5 V de l'Arduino.

3-Ajoutez la LED à votre plaque d'essai, en connectant la patte positive la plus longue à la broche 13 de l'Arduino via une résistance de 220 ohms et la patte la plus courte à la masse.

Le schéma

Dans ce schéma, vous assignez une broche au bouton-poussoir et la définissez comme entrée, et une broche à la LED comme sortie. Le code indique à l'Arduino d'allumer la LED tant que le bouton est enfoncé (fermant ainsi le circuit) et de la maintenir éteinte lorsque le bouton n'est pas enfoncé. Lorsque le bouton est relâché, le circuit est coupé et la LED s'éteint à nouveau.

le code

const int buttonPin = 2; const int ledPin = 13;             int buttonState = 0;

void setup() {

pinMode(ledPin, OUTPUT);

pinMode(buttonPin, INPUT); 

}

void loop() {

buttonState = digitalRead(buttonPin); 

if (buttonState == HIGH) { 

digitalWrite(ledPin, HIGH); 

} else {

digitalWrite(ledPin, LOW); 

} }

Découvrez : les entrées et sorties numériques, votre premier programme, les variables.

 CONSTRUIRE LE CIRCUIT

Connectez votre plaque d'essai aux connexions 5 V et à la masse de l'Arduino, comme pour le projet précédent. Placez les deux LED rouges et la LED verte sur la plaque d'essai. Reliez la cathode (courte branche) de chaque LED à la masse via une résistance de 220 ohms.

Connectez l'anode (longue branche) de la LED verte à la broche 3.

Connectez les anodes des LED rouges aux broches 4 et 5, respectivement.

Placez l'interrupteur sur la plaque d'essai comme dans le projet précédent. Connectez un côté à l'alimentation et l'autre à la broche numérique 2 de l'Arduino. 

Vous devrez également ajouter une résistance de 10 kOhms reliant la masse à la broche de l'interrupteur connectée à l'Arduino. Cette résistance de rappel relie la broche à la masse lorsque l'interrupteur est ouvert. Elle indique donc LOW lorsqu'aucune tension ne passe par l'interrupteur.

Vous pouvez recouvrir la plaque d'essai du gabarit fourni dans le kit. Ou la décorer pour créer votre propre système de lancement. Les lumières qui s'allument et s'éteignent ne signifient rien en elles-mêmes, mais en les plaçant dans un panneau de contrôle et en leur donnant des étiquettes, elles prennent tout leur sens. Que voulez-vous que signifie la LED verte ? Que signifient les LED rouges clignotantes? 

LE CODE

Quelques notes avant de commencer

Chaque programme Arduino possède deux fonctions principales. Les fonctions sont des parties d'un programme informatique qui exécutent des commandes spécifiques. Elles ont des noms uniques et sont appelées en cas de besoin. Les fonctions nécessaires à un programme Arduino sont setup() et loop(). Ces fonctions doivent être déclarées, ce qui signifie que vous devez indiquer à l'Arduino ce qu'elles feront.

setup() et loop() sont déclarées comme illustré à droite.

Dans ce programme, vous allez créer une variable avant d'entrer dans la partie principale du programme. Les variables sont des noms que vous attribuez à des emplacements dans la mémoire de l'Arduino afin de pouvoir suivre ce qui se passe. Ces valeurs peuvent changer en fonction des instructions de votre programme.

Les noms des variables doivent décrire la valeur qu'elles stockent. 

Par exemple, une variable nommée switchState indique ce qu'elle stocke : l'état d'un interrupteur. En revanche, une variable nommée « x » ne vous en dit pas beaucoup sur ce qu'elle stocke.

Commençons à coder

Pour créer une variable, vous devez déclarer son type. Le type de données int contient un nombre entier (également appelé entier) ; c'est-à-dire tout nombre sans virgule. 

Lorsque vous déclarez une variable, vous lui attribuez généralement une valeur initiale. Comme pour toute instruction, la déclaration de la variable doit se terminer par un point-virgule (;).

Configurer la fonctionnalité de broche.

La fonction setup() s'exécute une fois, à la première mise sous tension de l'Arduino.

C'est ici que vous configurez les broches numériques en entrées ou en sorties à l'aide d'une fonction nommée pinMode(). Les broches connectées aux LED seront des sorties et la broche de l'interrupteur sera une entrée.

Créer la fonction de boucle

La fonction loop() s'exécute en continu une fois la configuration terminée. La fonction loop() permet de vérifier la tension sur les entrées et d'activer et de désactiver les sorties. 

Pour vérifier le niveau de tension sur une entrée numérique, utilisez la fonction digitalRead() qui vérifie la tension sur la broche sélectionnée. Pour savoir quelle broche vérifier, digitalRead() attend un argument.

 Les arguments sont des informations que vous transmettez aux fonctions et qui leur indiquent comment elles doivent effectuer leur travail. Par exemple, digitalRead() a besoin d'un argument : quelle broche vérifier. Dans votre programme, digitalRead() vérifie l'état de broche 2 et stocke la valeur dans la variable switchState.

Si la broche est sous tension lors de l'appel de digitalRead(), la variable switchState prend la valeur HIGH (ou 1). En l'absence de tension, switchState prend la valeur LOW (ou 0).

{ Accolades }

Tout code écrit entre accolades sera exécuté à l'appel de la fonction.

  Respect de la casse

Soyez attentif à la casse

dans votre code.

Par exemple, pinMode est le nom d'une commande, mais pinmode génère une erreur

Commentaires

Si vous souhaitez inclure du langage naturel dans votre programme, vous pouvez laisser un commentaire.

Les commentaires sont des notes que vous laissez et que l'ordinateur ignore. Pour écrire un commentaire, ajoutez deux barres obliques. //

L'ordinateur ignorera tout ce qui se trouve sur la ligne qui suit ces barres obliques.

Ci-dessus, vous avez utilisé le mot « if » pour vérifier l'état d'un élément (à savoir la position de l'interrupteur). En programmation, une instruction if() compare deux éléments et détermine si la comparaison est vraie ou fausse. Elle exécute ensuite les actions que vous lui demandez. Pour comparer deux éléments en programmation, on utilise deux signes égal ==. Si vous n'utilisez qu'un seul signe, vous définissez une valeur au lieu de la comparer.

digitalWrite() est la commande qui permet d'envoyer 5 V ou 0 V à une broche de sortie. digitalWrite() prend deux arguments :

la broche à contrôler et sa valeur (HIGH ou LOW).

Si vous souhaitez allumer les LED rouges et éteindre la LED verte dans votre instruction if(), votre code ressemblera à ceci :

Vous avez indiqué à l'Arduino ce qu'il doit faire lorsque l'interrupteur est ouvert.

Définissez maintenant ce qui se passe lorsque l'interrupteur est fermé. L'instruction if() possède un composant else optionnel qui permet d'exécuter une action si la condition initiale n'est pas remplie. Dans ce cas, puisque vous avez vérifié si l'interrupteur était à l'état BAS, écrivez le code pour la condition HAUTE après l'instruction else.

Pour que les LED rouges clignotent lorsque le bouton est enfoncé, vous devez allumer et éteindre les lumières dans l'instruction else que vous venez d'écrire. Pour ce faire, modifiez le code comme suit :

Après avoir réglé les LED sur un certain état, l'Arduino

s'arrête un instant avant de les remettre à l'état initial. Si vous n'attendez pas, les lumières alterneront si vite qu'elles donneront l'impression d'être légèrement atténuées, et non pas allumées et éteintes. En effet, l'Arduino exécute sa fonction loop() des milliers de fois par seconde, et la LED s'allume et s'éteint plus vite que nous ne le percevons. La fonction delay() permet d'empêcher l'Arduino d'exécuter quoi que ce soit pendant un certain temps. delay() prend un argument qui détermine le nombre de millisecondes avant l'exécution du code suivant. Il y a 1 000 millisecondes dans une seconde. delay(250) marque une pause d'un quart de seconde.

Il peut être utile d'écrire le déroulement de votre programme en pseudo-code : une façon de décrire ce que vous souhaitez que le programme fasse en langage clair, mais structurée de manière à faciliter l'écriture d'un programme réel. Dans ce cas, vous allez déterminer si l'état du commutateur est à l'état HAUT (ce qui signifie que le bouton est enfoncé) ou non. 

Si l'interrupteur est enfoncé, vous éteignez la LED verte et allumez les LED rouges. En pseudo-code, l'instruction pourrait ressembler à ceci :

si l'état du commutateur est à l'état BAS :

allumer la LED verte

éteindre les LED rouges

si l'état du commutateur est à l'état HAUT :

éteindre la LED verte

allumer les LED rouges

Une fois votre Arduino programmé, vous devriez voir le voyant vert s'allumer. Lorsque vous appuyez sur l'interrupteur, les voyants rouges commencent à clignoter et le voyant vert s'éteint. 

Essayez de modifier la durée des deux fonctions delay() ; observez l'effet des voyants et la façon dont la réponse du système change en fonction de la vitesse de clignotement.

 L'appel d'une fonction delay() dans votre programme arrête toutes les autres fonctionnalités. Aucune mesure de capteur ne sera effectuée avant l'expiration de ce délai. Bien que les délais soient souvent utiles, lorsque vous concevez vos propres projets, assurez-vous qu'ils n'interfèrent pas inutilement avec votre interface.

Dans ce projet, vous avez créé votre premier programme Arduino pour contrôler le comportement de certaines LED à l'aide d'un interrupteur. Vous avez utilisé des variables, une instruction if()...else et des fonctions pour lire l'état d'une entrée et contrôler les sorties.

COMPRENDRE LA LOI D'OHM

 

Le courant, la tension et la résistance sont liés. Lorsque vous modifiez l'un de ces éléments dans un circuit, cela affecte les autres. Cette relation est connue sous le nom de loi d'Ohm, du nom de Georg Simon Ohm, qui l'a découverte.

TENSION (V) = COURANT (I) * RÉSISTANCE (R)

Lorsque vous mesurez l'ampérage des circuits que vous allez construire, les valeurs seront de l'ordre du milliampère. C'est-à-dire des millièmes d'ampère.

Dans le circuit illustré à la figure 5, vous fournissez 5 volts. La résistance offre une résistance de 220 ohms. Pour trouver l'ampérage utilisé par la LED, remplacez les valeurs de l'équation.

 Vous devriez obtenir 5 = I * 220. En divisant les deux côtés de l'équation par 220, vous obtenez I = 0,023. Cela représente 23 milliampères (23 mA) consommés par la LED. Cette valeur est à peu près la valeur maximale que vous pouvez utiliser en toute sécurité avec ces LED, c'est pourquoi vous avez utilisé une résistance de 220 ohms.

Vous pouvez étendre ce projet de plusieurs manières, soit en créant votre propre interrupteur (deux feuilles de papier aluminium avec du fil conviennent parfaitement), soit en combinant interrupteurs et LED en parallèle et en série. Que se passe-t-il lorsque vous mettez trois ou quatre LED en série ? Que se passe-t-il lorsqu'elles sont en parallèle ? Pourquoi se comporte-t-il ainsi ?

Un multimètre est un outil permettant de vérifier la résistance, le courant et la tension d'un circuit. Bien qu'il ne soit pas indispensable pour ces projets, il peut s'avérer utile dans la boîte à outils de tout ingénieur.

Vous avez découvert les propriétés électriques de la tension, du courant et de la résistance en construisant un circuit sur une platine d'expérimentation. Avec des composants tels que des LED, des résistances et des interrupteurs, vous avez créé le système interactif le plus simple : un utilisateur appuie sur un bouton et les lumières s'allument. Ces fondamentaux de l'électronique seront abordés et approfondis dans les projets à venir.

Dessiner un point avec Pygame.

Examinons ce programme ligne par ligne. Tout d'abord, nous importons

le module Pygame pour accéder à ses fonctionnalités. 

En ligne-2, nous initialisons Pygame, ou le configurons pour l'utiliser. La commande pygame.init() doit être appelée à chaque utilisation de Pygame, et elle intervient toujours après la commande import pygame et avant toute autre fonction Pygame.

En  ligne -3, pygame.display.set_mode([800,600]) crée une fenêtre d'affichage de 800 pixels de large sur 600 pixels de haut. Nous la stockons dans une variable appelée screen. Dans Pygame, les fenêtres et les graphiques sont appelés surfaces, et la surface d'affichage screen est la fenêtre principale où tous les autres graphiques seront dessinés.

En ligne 4, vous reconnaîtrez peut-être notre variable de boucle, keep_going :

nous l'avons utilisée dans nos boucles de jeu HighCard.py et FiveDice.py au chapitre 6 comme indicateur booléen pour indiquer à notre programme de continuer à jouer.

Ici, dans notre exemple Pygame, nous utilisons une boucle de jeu pour continuer à dessiner l'écran graphique jusqu'à ce que l'utilisateur ferme la fenêtre.

En ligne-5, nous définissons deux variables, GREEN et radius, pour dessiner notre cercle. La variable GREEN est définie sur la valeur du triplet RVB (0, 255, 0), un vert vif. (RVB, ou Rouge, Vert, Bleu, est l'une des nombreuses façons de spécifier une couleur. Pour choisir une couleur, il faut choisir trois nombres, chacun compris entre 0 et 255. Le premier nombre détermine.

La quantité de rouge dans votre couleur, le deuxième nombre correspond à la quantité de vert et le troisième au bleu. Nous avons choisi 255 comme valeur pour le vert et 0 pour le rouge et le bleu. Notre couleur RVB est donc entièrement verte, sans rouge ni bleu. Notre variable GREEN est une constante. Nous écrivons parfois des constantes (variables que nous ne souhaitons pas modifier) ​​en majuscules. Comme la couleur doit rester la même tout au long du programme, nous avons utilisé des majuscules pour GREEN. Nous définissons la variable radius à 50 pixels, pour un cercle de 100 pixels de diamètre.

 La boucle while en ligne-5 est notre boucle de jeu et continuera à exécuter la fenêtre Pygame jusqu'à ce que l'utilisateur décide de la quitter. La boucle for en ligne 6 gère tous les événements interactifs que l'utilisateur peut déclencher dans notre programme. Dans cet exemple simple, le seul événement que nous vérifions est si l'utilisateur a cliqué sur le X rouge pour fermer la fenêtre et quitter le programme. Si c'est le cas, keep_going est défini sur False (non)et notre boucle de jeu se termine.

https://solutionmeca.blogspot.com/2025/04/pygamedeplacer-limage-avec-la-sourie.html

 

pygame(déplacer l'image avec la sourie)

 

Nous avons besoin de deux images : une pour l'arrière-plan et une autre pour le curseur de la souris.  Si vous n'avez pas accès à Internet actuellement, vous pouvez utiliser les fichiers image de votre disque dur ou les créer avec n'importe quel logiciel de retouche photo ou graphique. N'importe quelle image convient pour l'arrière-plan(background), à condition qu'elle mesure au moins 640 x 480 (au-delà, l'excédent sera rogné). Pour le curseur de la souris(mouse_cursor), il vous faudra une image plus petite qui s'intègre parfaitement à l'arrière-plan ; une taille idéale est de 80 x 80. Pour poursuivre sur le thème du fugu du premier chapitre, l'arrière-plan officiel sera une image de bols et de baguettes, et une image d'un fugu très brut pour le curseur de la souris. Les deux premières lignes définissent les noms de fichiers des images ; si vous utilisez des images différentes, remplacez lés par leur emplacement.

Il initialise chacun des sous-modules du paquet Pygame, qui peut charger les pilotes et interroger le matériel afin que Pygame soit prêt à utiliser tous les périphériques de votre ordinateur. 

Vous pouvez initialiser uniquement les modules que vous souhaitez utiliser en appelant la fonction init dans chaque sous-module individuellement ; par exemple, pygame.sound.init() initialisera le module son. 

Cela peut accélérer le démarrage du script, car seuls les modules réellement utilisés seront initialisés. Pour les jeux, vous aurez besoin de la plupart, voire de la totalité, des modules ; nous nous en tiendrons donc à cette fonction d'initialisation fourre-tout. Après l'avoir appelée, nous disposons de toute la puissance de Pygame !

L'affichage peut être une fenêtre sur votre bureau ou l'écran entier, mais vous y accédez toujours via un objet Surface de Pygame. L'appel à pygame.display.set_mode dans notre script renvoie l'objet Surface représentant la fenêtre sur votre bureau. Il nécessite trois paramètres ; seul le premier est requis : il s'agit d'un tuple contenant la largeur et la hauteur de l'affichage que nous souhaitons créer. Notre fenêtre mesurera 640 × 480 pixels, ce qui est suffisant pour voir ce qui se passe, sans pour autant masquer une partie trop importante du bureau. 

Le paramètre suivant que nous donnons à set_mode est une valeur contenant les options utilisées lors de la création de l'affichage. Une option est une fonctionnalité qui peut être activée ou désactivée ; vous pouvez combiner plusieurs options avec l'opérateur OU binaire (|). Par exemple, pour créer une surface matérielle à double tampon, définissez le paramètre des options sur DOUBLEBUF|HWSURFACE.

La première chose que nous faisons avec notre surface nouvellement créée est d'appeler set_caption dans le module d'affichage pour définir la barre de titre de la fenêtre Pygame. Nous définissons le titre sur ( frist game with pygame)

La fonction load lit un fichier sur votre disque dur et renvoie une surface contenant les données de l'image. Ces objets sont du même type que notre écran, mais ils représentent des images stockées en mémoire et ne sont visibles qu'une fois affichés sur l'écran principal. Le premier appel à pygame.image.load lit l'image d'arrière-plan, puis appelle immédiatement convert, une fonction membre pour les objets Surface. Cette fonction convertit l'image au même format que notre écran, car il est plus rapide d'afficher des images à la même profondeur. Le curseur de la souris est chargé de la même manière, mais nous appelons convert_alpha plutôt que convert. En effet, l'image de notre curseur contient des informations alpha, ce qui signifie que certaines parties de l'image peuvent être translucides ou totalement invisibles. Sans ces informations, nous nous retrouvons limités à un carré ou un rectangle disgracieux ! Le chapitre suivant abordera plus en détail les formats alpha et image.

Cette boucle while a pour condition True (vrai), ce qui signifie qu'elle tournera en boucle jusqu'à ce que nous la quittions ou la forcions à quitter d'une autre manière. Tous les jeux ont une boucle similaire, qui se répète généralement une fois par rafraîchissement d'écran.

Un événement est la façon dont Pygame vous informe qu'un événement s'est produit en dehors de votre code. Les événements sont créés pour de nombreuses raisons, de l'appui sur une touche à la réception d'informations provenant d'Internet, et sont mis en file d'attente jusqu'à ce que vous les gériez. 

La fonction get du module pygame.event renvoie tous les événements en attente, que nous parcourons ensuite dans une boucle for. Pour ce script, nous nous intéressons uniquement à l'événement QUIT, généré par Pygame lorsque l'utilisateur clique sur le bouton de fermeture de la fenêtre Pygame. 

Ainsi, si l'événement est de type QUIT, nous appelons keep_going=False  pour fermer le programme, et tous les autres événements sont ignorés. Dans un jeu, bien sûr, nous aurions à gérer un plus grand nombre d'événements.

Cette ligne utilise la fonction membre blit de l'objet Surface de l'écran, qui prend une image source (ici, notre arrière-plan de( 800 × 800) et un tuple contenant la position de destination.

 L'arrière-plan ne bougera jamais ; nous souhaitons simplement qu'il recouvre toute la fenêtre Pygame. Nous effectuons donc un blit à la coordonnée (400, 400), qui correspond au center de l'écran.

Obtenir la position de la souris est simple et efficace ; le module pygame.mouse contient tout ce dont nous avons besoin pour utiliser la souris, y compris get_pos, qui renvoie un tuple contenant les coordonnées de la souris. 

La première ligne décompose ce tuple en deux valeurs pour plus de commodité : x et y. Nous pourrions utiliser ces deux valeurs comme coordonnées lorsque nous déplacerions le curseur de la souris, mais cela placerait le coin supérieur gauche de l'image sous la souris, et nous souhaitons que le centre de l'image soit sous la souris. 

Nous effectuons donc un petit calcul (pas de panique !) pour ajuster x et y afin que l'image de la souris soit déplacée de moitié vers le haut et de moitié vers la gauche. Ces coordonnées placent le centre de l'image juste sous le pointeur de la souris, ce qui est plus esthétique.

 C'est du moins le cas pour l'image d'un poisson. Si vous souhaitez utiliser une image de pointeur plus classique, ajustez les coordonnées pour que la pointe se trouve sous les coordonnées réelles de la souris. Le blitting de l'image de la souris s'effectue de la même manière que celui de l'arrière-plan, mais nous utilisons les coordonnées calculées plutôt que (0, 0). 

Cela suffit pour obtenir l'effet recherché, mais il reste encore une étape à franchir avant de pouvoir visualiser quoi que ce soit :

Lorsque vous créez une image à l'aide de blits à l'écran, vous ne les voyez pas immédiatement.

 En effet, Pygame crée d'abord l'image dans un tampon arrière, un affichage invisible en mémoire, avant de l'afficher. Sans cette étape, l'utilisateur verrait les blits individuellement au fur et à mesure qu'ils se produisent, ce qui provoquerait un scintillement désagréable.

 Pour les programmeurs de jeux vidéo, le scintillement est l'ennemi numéro un ! Nous voulons une animation fluide et convaincante. Heureusement, un appel à pygame.display.update() suffit pour garantir que l'image créée en mémoire s'affiche sans scintillement.

https://solutionmeca.blogspot.com/2025/04/dessiner-un-point-avec-pygame.html