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

Un livre de Wikilivres.
Contenu supprimé Contenu ajouté
plan en anglais
→‎Le jeu pygame de base : lien vers l'image manquante
Ligne 49 : Ligne 49 :
Pour la révision (ça ne peut pas faire de mal), et pour s'assurer que vous êtes familier avec la structure d'un programme python standard, je vais brièvement parcourir un programme python simple, qui n'affichera rien de plus qu'une fenêtre avec un peu de texte à l'intérieur, et qui devrait finalement ressembler à ça (naturellement, la décoration de la fenêtre pourra être différente sur votre système) :
Pour la révision (ça ne peut pas faire de mal), et pour s'assurer que vous êtes familier avec la structure d'un programme python standard, je vais brièvement parcourir un programme python simple, qui n'affichera rien de plus qu'une fenêtre avec un peu de texte à l'intérieur, et qui devrait finalement ressembler à ça (naturellement, la décoration de la fenêtre pourra être différente sur votre système) :


[http://www.pygame.org/docs/tut/tom/basic.png ICI une image manquante]

ICI une image manquante


Dans cet exemple, le code complet ressemble à ça :
Dans cet exemple, le code complet ressemble à ça :

Version du 29 février 2008 à 21:24


Cette page est considérée comme une ébauche à compléter . Si vous possédez quelques connaissances sur le sujet, vous pouvez les partager en éditant dès à présent cette page (en cliquant sur le lien « modifier »).

Ressources suggérées : http://www.pygame.org/docs/tut/tom/MakeGames.html

Introduction

Dans ce tutoriel, je suppose que vous avez lu le tutoriel Chimp Ligne par Ligne, qui introduit les bases de python et de Pygame. Dans le cas contraire, prenez en connaissance avant de lire ceci, car je ne redonnerai pas les bases que Chimp - Ligne par ligne fournit (en tous cas, pas dans les détails). Ce tutoriel est destiné à ceux qui ont les connaissances théoriques pour réaliser un "jeu" , et qui aimeraient produire un petit jeu simple comme Pong. Il vous introduit quelques concepts, comme le design des jeux, quelques simples notions mathématiques physiques pour manipuler un objet comme une balle, et comment garder votre jeu simple à maintenir et à améliorer.

Tout le code de ce tutoriel est utilisé dans TomPong, un jeu que j'ai écrit. A la fin de ce tutoriel, vous devriez non seulement renforcer votre compréhension de Pygame, mais vous devriez aussi comprendre comment TomPong fonctionne, et comment concevoir votre propre version.

Maintenant, faisons une brève revue des bases d'utilisation de Pygame.

Une méthode commune d'organisation du code d'un jeu est de le diviser en six parties distinctes :

  • Le chargement des modules qui sont utilisés dans le jeu

Tous les modules standards, excepté les importations locales des espaces de nommage de Pygame et le module Pygame lui-même.

  • Les classes de base du jeu

La définition des classes gérant les ressources de base, que sont le chargement des images et des sons, ainsi que les procédures de connexion/déconnexion au réseau, le chargement des sauvegardes de jeu, et toutes les autres ressources que vous pouvez utiliser dans votre jeu.

  • Les classes des objets du jeu

Cette partie devra contenir les définitions de classes pour les objets de votre jeu. Dans l'example de Pong, ce sera un objet pour la raquette du joueur (que vous pouvez initialiser plusieurs fois, une pour chaque joueur dans le jeu), et une pour la balle (laquelle peut aussi avoir de multiples instances). Si vous souhaitez avoir un menu sympa pour votre jeu, c'est aussi une bonne idée de faire une classe pour le menu.

  • Toutes les autres fonctions du jeu

Dans cette partie seront contenus toutes les autres fonctions nécessaires à la bonne marche du jeu, comme par exemple celles qui définissent le classement des scores, la gestion du menu, etc. Tout le code que vous pourriez mettre dans le jeu principal, mais qui le rendrait difficilement lisible et peu cohérent, devrait être contenu dans cette partie. Par exemple, tracer une courbe d'évolution du score ne relève pas du jeu en lui-même, cela devrait être fait par une fonction particulière située dans cette partie.

  • L'initialisation du jeu

Cela inclut les objets Pygame eux-mêmes, le fond, les objets du jeu (initialisation des instances de classe) et les autres petits morceaux de code que vous pourriez vouloir ajouter.

  • La boucle principale

C'est dans cette boucle que vous placerez la gestion des entrées (c'est à dire l'acquisition des évènements utilisateurs que sont les frappes de clavier/bouton de souris), le code de mise à jour des objets du jeu, et finalement la mise à jour de l'écran.

Chaque jeu que vous ferez aura certaines seulement, ou la totalité de ces sections, avec vos propres ajouts de sections. Dans le cadre de ce tutoriel, je parlerai de la façon dont TomPong est agencé, et de la façon d'appliquer cette organisation à chaque projet de jeu que vous pourriez avoir.

Je supposerai également que vous voudrez garder tout le code dans un seul fichier, mais si vous faites un jeu raisonnablement conséquent en taille de code, c'est souvent une bonne idée de séparer le jeu en fichiers de modules.

Mettre les classes des objets du jeu dans un fichier objects.py par exemple, peut vous aider à séparer la programmation du jeu en lui-même des objets. Si vous avez un code de gestion des ressources, il peut également être pratique de le mettre dans resources.py. Vous pourrez alors écrire from objects, resources import * pour importer toutes les classes et les fonctions.

Une remarque sur le style d'écriture

La première chose à laquelle il faut penser, en envisageant quelque projet informatique de programmation, est de décider de normes pour le style d'écriture, et de les conserver. Python en lui-même facilite cela, à cause de son interprétation stricte des espaces et de l'indentation, mais cela ne vous empêche pas de choisir la largeur de votre indentation, de quelle manière vous placerez les importations, comment vous allez commenter le code ; vous n'avez pas besoin de réutiliser mon style, mais quelque soit celui que vous adopterez, conservez-le dans tout votre code et vos programmes. Essayez également de documenter toutes vos classes, et de commenter tous les morceaux de code qui peuvent sembler obscurs. Egalement, il ne sert à rien de commenter ce qui est évident. J'ai vu beaucoup de personnes faire la chose suivante :

player1.score += scoreup	# Add scoreup to player1 score

Ce n'est pas très grave, mais un peu inutile.

Le code le plus horrible est mal agencé, avec des changements aléatoires dans le style d'écriture, et une maigre documentation. Le pire code n'est pas seulement ennuyeux pur les autres gens, mais il est également difficile à maintenir pour vous.

Révision : les fondamentaux de pygame

Le jeu pygame de base

Pour la révision (ça ne peut pas faire de mal), et pour s'assurer que vous êtes familier avec la structure d'un programme python standard, je vais brièvement parcourir un programme python simple, qui n'affichera rien de plus qu'une fenêtre avec un peu de texte à l'intérieur, et qui devrait finalement ressembler à ça (naturellement, la décoration de la fenêtre pourra être différente sur votre système) :

ICI une image manquante

Dans cet exemple, le code complet ressemble à ça :

#!/usr/bin/python

import pygame
from pygame.locals import *

def main():
	# Initialise screen
	pygame.init()
	screen = pygame.display.set_mode((150, 50))
	pygame.display.set_caption('Basic Pygame program')

	# Fill background
	background = pygame.Surface(screen.get_size())
	background = background.convert()
	background.fill((250, 250, 250))

	# Display some text
	font = pygame.font.Font(None, 36)
	text = font.render("Hello There", 1, (10, 10, 10))
	textpos = text.get_rect()
	textpos.centerx = background.get_rect().centerx
	background.blit(text, textpos)

	# Blit everything to the screen
	screen.blit(background, (0, 0))
	pygame.display.flip()

	# Event loop
	while 1:
		for event in pygame.event.get():
			if event.type == QUIT:
				return

		screen.blit(background, (0, 0))
		pygame.display.flip()


if __name__ == '__main__': main()

Basic Pygame objects

Blitting

The event loop

Ta-da!

Kicking things off

The first lines, and loading modules

Resource handling functions

Game object classes

A simple ball class

Diversion 1: Sprites

Diversion 2: Vector physics

User-controllable objects

A simple bat class

Diversion 3: Pygame events

Putting it all together

Let the ball hit sides

Let the ball hit bats

The Finished product