« Pygame/Déplacer une image » : différence entre les versions

Contenu supprimé Contenu ajouté
m Formatage, ajout de code
Ligne 11 :
== De simples pixels sur l'écran ==
 
Pygame possède une Surface d'affichage. C'est typiquement l'image visible à l'écran, et cette image est constituée de pixels. La principale façon de modifier ces pixels est d'appeler la fonction <ttcode>blit()</ttcode> : elle copie les pixels d'une image sur une autre.
 
C'est la première chose à comprendre. En appelant la fonction <ttcode>blit()</ttcode> d'une image sur l'écran, vous changez simplement la couleur des pixels de l'écran. Les pixels ne sont pas ajoutés ou déplacés, c'est seulement la couleur de certains pixels qui est modifiée. Ces images que vous ''blitez'' sur l'écran sont des Surfaces dans Pygame, mais elles ne sont aucunement connectées à la Surface d'affichage. Quand elles sont ''blitées'' sur l'écran, elles sont copiées sur la Surface d'affichage, mais vous avez toujours accès à l'image originale.
 
Avec cette brève description, peut-être pouvez-vous déjà comprendre ce que nécessite l'animation d'une image. En réalité, nous ne déplaçons rien. Nous faisons simplement un ''blit'' de l'image dans une nouvelle position. Mais avant de dessiner l'image dans une nouvelle position, il faut effacer l'ancienne. Autrement, l'image serait visible à deux places sur l'écran. En effaçant rapidement l'image et en la redessinant à un nouvel endroit, nous réalisons ''l'illusion'' du mouvement.
Ligne 52 :
</source>
 
Maintenant il est assez facile de le déplacer vers une nouvelle position. Changeons simplement la valeur de <ttcode>playerpos</ttcode>, et dessinons-le une nouvelle fois à l'écran.
 
<source lang="python">
Ligne 122 :
 
Utiliser le code que nous avons vu dans les exemples plus haut, et le faire fonctionner avec Pygame est très simple :
# Nous supposons que nous avons chargé de jolies images et que nous les avons nommées : <ttcode>terrain1</ttcode>, <ttcode>terrain2</ttcode> et <ttcode>hero</ttcode>.
# Où nous avons assigné plus tôt des nombres à une liste, maintenant nous allons ''bliter'' des images à l'écran.
# Un autre grand changement, au lieu d'employer des positions en tant que simple index (de 0 à 5), nous aurons besoin de coordonnées à deux dimensions. Nous supposerons également que chaque image de notre jeu aura une largeur de 10 pixels donc avec des positions multiples de 10. Cela revient à multiplier les indices par 10 pour obtenir les coordonnées.
Ligne 140 :
J'espère que mon illustration sur le paramétrage de valeurs simples dans une liste montre la similarité avec le paramétrage de pixels sur l'écran (avec blit).
La seule partie qui soit un travail supplémentaire est celle qui convertit la position du joueur en coordonnée sur l'écran.
Pour l'instant nous utilisons simplement <ttcode>(playerpos*10, 0)</ttcode>, mais nous pouvons certainement faire mieux que ça.
 
Maintenant déplaçons l'image du joueur dans un autre endroit.
Ligne 161 :
== Coordonnées écran ==
 
Pour positionner un objet sur l'écran, nous avons besoin de la fonction <ttcode>blit()</ttcode> où l'on met l'image. Dans Pygame nous passons toujours nos positions comme des coordonnées (X,Y). X est le nombre de pixels vers la droite et Y le nombre de pixels vers le bas. Le coin supérieur gauche d'une Surface correspond aux coordonnées <ttcode>(0, 0)</ttcode>. Un déplacement vers la droite donnerait <ttcode>(10, 0)</ttcode>, et ajouter un déplacement vers le bas nous donnerait <ttcode>(10, 10)</ttcode>. Quand nous blitons, l'argument passé en position représente le coin supérieur gauche de la source devant être placé sur la destination.
 
Pygame possède un conteneur intéressant, l'objet <ttcode>Rect</ttcode>. L'objet <ttcode>Rect</ttcode> représente une zone rectangulaire avec ses coordonnées. Il est défini par son coin supérieur gauche et sa dimension. L'objet <ttcode>Rect</ttcode> possède de nombreuses méthodes utiles qui peuvent vous aider à le déplacer et le positionner. Dans notre prochain exemple, nous représenterons les positions de nos objets avec des <ttcode>Rect</ttcode>.
 
Ensuite sachez que beaucoup de fonctions de Pygame utilisent les attributs des objets <ttcode>Rect</ttcode>. Toutes ces fonctions peuvent accepter un simple tuple de 4 éléments (position gauche, position dessus, largeur, hauteur). Vous n'êtes pas toujours obligé d'utiliser ces objets <ttcode>Rect</ttcode>, mais vous les trouverez utiles. Ainsi, la fonction <ttcode>blit()</ttcode> peut accepter un objet <ttcode>Rect</ttcode> en tant qu'argument de position, elle utilise le coin supérieur gauche du <ttcode>Rect</ttcode> comme position réelle.
 
== Changer l'arrière-plan ==
Ligne 171 :
Dans toutes nos sections précédentes, nous avons stocké l'arrière-plan comme étant une liste de différents types de sol. C'est une bonne manière de créer un jeu basé sur des cases, mais nous voulons faire un défilement (''scrolling'' en anglais) fluide. Pour faire simple, nous commencerons par modifier l'arrière-plan en une simple image qui couvre entièrement l'écran. De cette façon, quand nous voudrons effacer nos objets (avant de les redessiner) nous aurons simplement besoin de bliter la section effacée de l'arrière-plan dans l'écran.
 
En passant un troisième argument optionnel à la fonction <ttcode>blit()</ttcode>, nous lui indiquerons de bliter uniquement une sous-section de l'image source. Vous la verrez en action quand nous effacerons l'image du joueur.
 
Notez également, que lorsque nous aurons fini de tout dessiner, nous invoquerons la fonction <ttcode>pygame.display.update()</ttcode> qui affichera tout ce que nous avons dessiné sur l'écran.
 
== Mouvement fluide ==
Ligne 197 :
Et voilà. Ceci correspond au code nécessaire pour animer de façon fluide un objet à travers l'écran. Nous pouvons aussi utiliser un joli personnage d'arrière-plan. Un autre avantage sur cette façon de procéder, est que l'image du joueur peut inclure de la transparence ou être découpée en section, elle sera toujours dessinée correctement sur l'arrière-plan.
 
Nous avons aussi fait appel à la fonction <ttcode>pygame.time.delay()</ttcode> à la fin de notre boucle. Ceci pour ralentir un peu notre programme, autrement il tournerait tellement vite et l'on aurait pas le temps de le voir.
 
== Et ensuite ? ==
 
Si tout va bien, cet article a fait tout ce qu'il avait promis de faire. Mais à ce stade, le code n'est pas encore prêt pour réaliser le prochain jeu le plus vendu. Comment faire pour obtenir simplement de multiple déplacements d'objets ? Que sont réellement ces mystérieuses fonctions comme <ttcode>load_player_image()</ttcode> ? Nous avons également besoin d'une manière simple d'accéder aux entrées de l'utilisateur (clavier, souris ou autre), et boucler sur plus de 100 images. Nous prendrons l'exemple que nous avons ici, et le transformerons en une création orientée objet qui rendra notre maman très fière.
 
== Les fonctions mystères ==
 
Des informations complètes sur ces types de fonctions peuvent être trouvées dans d'autres tutoriaux et références. Le module <ttcode>pygame.image</ttcode> possède une fonction <ttcode>load()</ttcode> qui fera ce que nous voudrons. Les lignes pour charger des images devraient ressembler à ceci.
 
<source lang="python">
Ligne 212 :
</source>
 
Nous pouvons voir la simplicité de l'exemple, la fonction de chargement demande seulement un nom de fichier et retourne une nouvelle surface avec l'image chargée. Après le chargement, nous faisons appel à la méthode de Surface : <ttcode>convert()</ttcode>. <ttcode>convert()</ttcode> nous retourne une nouvelle Surface contenant l'image, mais convertie dans le même [[w:Espace colorimétrique|espace colorimétrique]] que notre affichage. Maintenant que les images ont le même format d'affichage, le blit est très rapide. Si nous ne faisons pas la conversion, la fonction <ttcode>blit()</ttcode> est plus lente, c'est pourquoi il est préférable de faire la conversion de pixels d'un format à un autre au fur et à mesure.
 
Vous avez certainement dû remarquer que les deux fonctions, <ttcode>load()</ttcode> et <ttcode>convert()</ttcode>, retournent de nouvelles Surfaces. Ceci signifie que nous avons réellement créé deux Surfaces à chacune de ces lignes. Dans d'autres langages de programmation, on obtiendrait une fuite de mémoire (ce n'est clairement pas une bonne chose). Heureusement Python est suffisamment intelligent pour les gérer, et Pygame effacera proprement la Surface que nous n'utiliserons pas.
 
Cette autre fonction mystérieuse que nous avons vue dans l'exemple précédent était <ttcode>create_screen()</ttcode>. Dans Pygame, c'est simple de créer une nouvelle fenêtre pour les graphismes. Le code pour créer une surface de 640X480 pixels est le suivant. Sans passer aucun autre argument, Pygame choisit la meilleure profondeur de couleur et le meilleur espace colorimétrique pour nous.
 
<source lang="python">
Ligne 252 :
</source>
 
Nous avons donc deux fonctions dans notre classe. La méthode <ttcode>__init__()</ttcode> construit notre objet. Elle le positionne et définit sa vitesse. La méthode <ttcode>move()</ttcode> bouge l'objet d'un pas. S'il va trop loin, elle déplace l'objet en arrière vers la gauche.
 
== Positionner le tout ==
Ligne 284 :
== Les mots de la fin ==
 
Alors quelle sera la prochaine étape sur la route de votre apprentissage ? D'abord, jouer un peu avec cet exemple. La version complète de cet exemple est disponible dans le répertoire <ttcode>examples</ttcode> de Pygame, sous le nom <ttcode>moveit.py</ttcode>. Jetez un coup d'oeil sur le code et jouez avec, lancez-le et apprenez-le.
 
Il y a plusieurs choses que vous pouvez faire avec, comme utiliser plus d'un type d'objet. Trouvez une façon pour supprimer proprement les objets quand vous ne désirez plus les afficher. Pour faire une mise à jour, utilisez la méthode <ttcode>display.update()</ttcode> pour passer une liste de zones d'écran qui ont changé.
 
Il existe beaucoup d'autres tutoriaux et exemples pour Pygame qui peuvent vous aider en toutes circonstances. Alors maintenant, pour retenir en apprenant, retenez en lisant. : ^)