« Pygame/Concevoir des jeux avec Pygame » : différence entre les versions

relecture en survol
(→‎Le produit final : faute de frappe)
(relecture en survol)
Pour l'arrière-plan, nous créons d'abord un objet Surface et lui donnons la taille de la fenêtre. Nous utilisons ensuite la méthode <tt>convert()</tt> pour convertir la Surface en un unique [[w:Espace colorimétrique|espace colorimétrique]]. C'est particulièrement recommandé lorsque nous manipulons plusieurs images et surfaces, toutes dans un espace colorimétrique différent, sinon cela ralentirait de beaucoup le rendu. En convertissant toutes les surfaces, nous pouvons accélérer drastiquement les temps de rendu. Enfin nous remplissons la surface d'arrière-plan en blanc (255, 255, 255). Ces valeurs sont en RGB et nous pouvons les retrouver à partir de n'importe quel bon programme de dessin.
 
En ce qui concerne le texte, nous avons besoin de plus d'un objet. D'abord nous créons un objet <tt>font</tt>, qui définira quelle police nous utiliserons, ainsi que sa taille. Ensuite nous créons un objet <tt>text</tt>, en utilisant la méthode de rendu de notre objet <tt>font</tt> et en lui fournissant trois arguments : le texte à faire le rendu, qui sera ou non anti-aliasécrénelé (1=oui, 0= non), ainsi que la couleur du texte (toujours dans un format RGB). Ensuite nous créons un troisième objet texte qui fournira le rectangle du texte. La manière la plus simple à comprendre est de s'imaginer en train de dessiner un rectangle qui englobera tout le texte. Vous pourrez alors utiliser ce rectangle afin d'obtenir ou de définir la position du texte sur la fenêtre d'affichage. Ainsi dans cet exemple nous avons le rectangle, et définissons ses attributs <tt>centerx</tt> et <tt>centery</tt> pour correspondre aux <tt>centerx</tt> et <tt>centery</tt> de l'arrière-plan, alors le texte aura le même centre que l'arrière-plan. Dans cet exemple, le texte sera centré sur les axes <tt>x</tt> et <tt>y</tt> de la fenêtre d'affichage.
 
=== Blitting ===
 
Maintenant que nous avons créé les objets de notre jeu, nous avons besoin d'en faire le rendu. Si nous ne le faisons pas et que nous exécutons le programme, nous ne verrons qqu'une fenêtre blanche, et nos objets resteronsresteront invisibles. Le terme employé pour faire un rendu des objets est le ''blitting'' (que nous franciserons par ''blit''), qui correspond à la copie de pixels d'un objet source vers un objet de destination. Ainsi pour faire une rendu de l'objet <tt>background</tt>, vous le blitez<!-- aah !--> sur l'objet <tt>screen</tt>. Dans cet exemple, pour faire les choses simples, nous blitons le texte sur l'arrière-plan (donc l'arrière-plan possède une copie du texte sur lui), et ensuite nous blitons l'arrière-plan sur l'écran.
 
Le blit est une des opérations les plus lentes dans un jeu, vous devez donc faire attention à ne pas trop faire de blit sur l'écran pour chaque image. Par exemple, si vous avez une image d'arrière-plan, et une balle se déplaçant à travers l'écran, alors vous pouvez bliter l'arrière-plan en entier et ensuite la balle, tout ceci à chaque image, ce qui recouvrira la position précédente de la balle et fera un rendu de la nouvelle balle, mais ce sera plutôt lent. Une meilleure solution consiste à bliter une partie de l'arrière-plan sur la zone occupée par la balle à l'image précédente, qui peut être trouvée grâce au <tt>rect</tt> de la balle précédente, et ensuite bliter la nouvelle balle, ce qui aura pour effet de bliter seulement deux petites zones.
== Coup d'envoi ==
 
Les premières sections du code sont relativement simples, et une fois écrites peuvent habituellement être réutilisées dans tous les jeux que vous programmerez. Elles s'occuperont de toutes les tâches fastidieuses et génériques comme : charger des modules, charger des images, ouvrir des connections réseau, jouer de la musique, etc. Elles incluerontincluront également de simples mais efficaces gestionnaire d'erreurs, et les quelques personnalisations que vous souhaiterez effectuer par dessus les fonctions fournies par des modules comme <tt>sys</tt> et <tt>pygame</tt>.
 
=== Les premières lignes et le chargement de modules ===
=== Fonctions de gestion des ressources ===
 
Dans l'exemple [[Pygame/Chimp_-_Ligne_par_ligne|Chimp - Ligne par ligne]], le premier code à être écrit correspond au chargement des images et des sons. EtantÉtant donné que c'est totalement indépendant de la logique de jeu et/ou des objets de jeu, elles seront écrites en premier et dans des fonctions séparées, ce qui impliquera que le code qui s'ensuivra pourra les utiliser. Je mets généralement tout mon code de cette nature au départ, dans leur propre fonctions, sans classe. Cela correspondra aux fonctions de gestions des ressources. Vous pouvez bien sûr créer des classes pour celle-ci, c'est à vous de développer votre propre style et vos meilleures pratiques.
 
C'est toujours une bonne idée d'écrire vos propres fonctions de gestion de ressources, car bien que Pygame possède des méthodes pour l'ouverture des images et des sons (ainsi que d'autres modules qui possèdent eux aussi leurs propres méthodes pour l'ouverture d'autres ressources), ces méthodes peuvent prendre plus d'une ligne, et peuvent requérir de consistantes modifications faites par vous-mêmes, et bien souvent elles ne fournissent pas de gestion d'erreur satisfaisante. EcrireÉcrire des fonction de gestion de ressources vous donne un code sophistiqué, réutilisable, et vous offre plus de contrôle sur vos ressources. Prenez cet exmpleexemple d'une fonction de chargement d'image :
 
<source lang="python">
</source>
 
Ici nous avons créé une fonction de chargement d'image plus sophistiquée que celle fournie par Pygame : <tt>image.load()</tt>. AÀ noter que la première ligne de la fonction débute par un ''docstring'' (chaine de caractère de documentation) qui décrit ce que fait la fonction et quel objet elle retourne. La fonction suppose que toutes vos images soient dans un répertoire appelé <tt>data<tt>, et donc utilisera le nom de fichier et créera le chemin complet (par exemple <tt>data/ball.png</tt>), en utilisant le module <tt>os</tt> pour s'assurer de la compatibilité entre plateforme différente (Linux, MacOS, Windows, ...). Ensuite elle essaye de charger l'image, et de convertir les régions alpha (ce qui vous permettra d'utiliser la transparence), et le cas échéant retourne une erreur ''lisible par un être humain'' si elle rencontre un problème. Finalement elle retourne un objet image, ainsi que son <tt>rect</tt>.
 
Vous pouvez créer des fonctions similaires pour le chargement de n'importe quelle autre ressource, tel que le chargement des sons. Vous pouvez aussi créer des classes de gestion de ressources, pour vous donner plus de flexibilité avec des ressources plus complexes. Par exemple, vous pouvez créer une classe <tt>Music</tt>, avec une fonction <tt>__init__()</tt> qui charge le son (peut-être en empruntant la fonction <tt>load_sound()</tt>), une méthode pour mettre en pause la musique, une méthode pour la redémarrer. Une autre classe de gestion de ressources utile peut être créée pour les connexions réseau. Des fonctions pour ouvrir des [[Apprendre à programmer avec Python/Communications à travers un réseau|sockets]], passer des données avec une sécurité appropriée et muni d'un contrôle d'erreur, fermer des sockets, [http://jargonf.org/wiki/finger finger] des adresses, ainsi que d'autres tâches concernant le réseau, pourront rendre l'écriture d'un jeu avec des capacités réseau moins pénible.
8 843

modifications