oujood.com

Travailler avec du Texte en Pygame : Un Guide Complet

Ce tutoriel vous guidera à travers les étapes pour travailler avec du texte en Pygame, en mettant l'accent sur la création, l'affichage et la gestion du texte dans vos jeux

Pygame est une bibliothèque de développement de jeux en Python qui offre des fonctionnalités puissantes pour la création de jeux 2D. L'une des composantes essentielles de tout jeu est la gestion du texte, que ce soit pour afficher des instructions, des scores ou des dialogues.

Afficher du Texte

Pygame propose la classe pygame.font.Font pour travailler avec du texte. Voici un exemple simple qui affiche du texte à l'écran :

Exemple :       Copier le code

import pygame
pygame.init()

# Définir la taille de la fenêtre
largeur, hauteur = 800, 600
fenetre = pygame.display.set_mode((largeur, hauteur))
pygame.display.set_caption("Travailler avec du Texte en Pygame")

# Boucle principale
en_cours = True
while en_cours:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            en_cours = False

        # Créer une police
    police = pygame.font.Font(None, 36)

    # Créer un objet texte
    texte = police.render("Bonjour, Pygame !", True, (255, 255, 255))

    # Positionner le texte à l'écran
    position_texte = (200, 300)

    # Afficher le texte à l'écran
    fenetre.blit(texte, position_texte)


    pygame.display.flip()

pygame.quit()


Dans cet exemple, la méthode render prend le texte, un booléen pour l'antialiasing, et la couleur du texte en RGB.

Pygame - Travailler avec du texte

Initialisation des polices

Nous pouvons maintenant passer à la partie initialisation des polices de caractères. Pour travailler avec du texte il faut initialiser les polices. La méthode pygame.font.init() est utilisée pour initialiser la police et la méthode pygame.font.get_init() est utilisée pour vérifier si la police a été initialisée ou non. Ces deux méthodes ne nécessitent aucun argument. Si la police a été initialisée avec succès, la méthode pygame.font.get_init() renvoie true.

Impression de texte dans un écran

Nous allons voir ici comment obtenir une police et un texte personnalisés sur l'écran. Nous définirons la position des textes à afficher à l'écran à l'aide des coordonnées x et y. Nous allons d'abord créer les fichiers de police, puis rendre les textes. La fonction screen.blit() est utilisée pour copier les objets de la surface du texte vers les objets de la surface d'affichage aux coordonnées du centre.

Exemple :       Copier le code

import pygame
 
# initialisation de pygame
pygame.font.init()
 
# vérifie si la police est initialisée
# ou non
pygame.font.get_init()
 
# créer la surface d'affichage
display_surface = pygame.display.set_mode((800, 500))
 
# changer le titre de l'écran de la fenêtre
pygame.display.set_caption('Notre texte')
 
# Créer un fichier de police en passant le fichier de police
# et la taille de la police
font1 = pygame.font.SysFont('freesanbold.ttf', 40)
font2 = pygame.font.SysFont('chalkduster.ttf', 30)
 
# Rendez les textes que vous voulez afficher
text1 = font1.render('oujood.com est le bon site pour apprendre python', True, (0, 255, 0))
text2 = font2.render('J\'appreds python avec le site oujood.com', True, (0, 0, 250))
 
# créer un objet rectangulaire pour l'objet surface
# l'objet surface du texte
textRect1 = text1.get_rect()
textRect2 = text2.get_rect()
 
# définir le centre du premier texte
textRect1.center = (400, 250)
 
# centrage du deuxième texte
textRect2.center = (400, 300)
 
while True :
 
    # ajouter la couleur d'arrière-plan en utilisant les valeurs RVB
    display_surface.fill((0, 0, 0))
 
    # copier les objets de la surface de texte
    # vers les objets de la surface d'affichage
    # à la coordonnée centrale.
    display_surface.blit(text1, textRect1)
    display_surface.blit(text2, textRect2)
 
    # itère sur la liste des objets Event
    # qui a été retournée par la méthode pygame.event.get()
    # par la méthode pygame.event.get().
    for event in pygame.event.get() :
 
        if event.type == pygame.QUIT :
           
            # désactivation de la bibliothèque pygame
            pygame.quit()
 
            # quitter le programme.
            quit()
 
        # mise à jour de l'affichage
        pygame.display.update()

Entrée du curseur dans la fenêtre

Nous allons ajouter une note de curseur clignotant ici. Notre curseur continuera à clignoter toutes les 0,5 secondes. Nous pouvons également éditer notre texte.

Exemple :       Copier le code

# Importer le module pygame
import pygame

# Importer le module time
import time

# Initialiser le module pygame
pygame.init()

# Définir la taille de la fenêtre
fenetre = pygame.display.set_mode((500, 500))

# Ajouter un peu de texte
texte = 'Salut tout le monde !!'

# Ajouter le style de police par défaut avec une taille de police
police = pygame.font.SysFont(None, 40)

# Rendre le texte
img = police.render(texte, True, (255, 0, 0))

rect = img.get_rect()
rect.topleft = (20, 20)
curseur = pygame.Rect(rect.topright, (3, rect.height))

en_cours = True

while en_cours:
	
	for event in pygame.event.get():
		if event.type == pygame.QUIT:
			en_cours = False

		# Détecter si une touche est physiquement enfoncée
		if event.type == pygame.KEYDOWN:
			if event.key == pygame.K_BACKSPACE:
				if len(texte) > 0:
					
					# Conserve le texte sauf le dernier caractère
					texte = texte[:-1]

			else:
				texte += event.unicode
				
			img = police.render(texte, True, (255, 0, 0))
			rect.size = img.get_size()
			curseur.topleft = rect.topright

	# Ajouter une couleur de fond à la fenêtre
	fenetre.fill((200, 255, 200))
	fenetre.blit(img, rect)
	
	# Le curseur clignote toutes les 0.5 secondes
	if time.time() % 1 > 0.5:
		pygame.draw.rect(fenetre, (255, 0, 0), curseur)
		
	# Mettre à jour l'affichage
	pygame.display.update()

pygame.quit()

Boîte de saisie(input box) sur la fenêtre

Ici nous allons voir comment lire le texte en utilisant le clavier dans pygame. Nous allons afficher notre texte à l'intérieur d'un rectangle. Lorsque la souris passe sur le rectangle, la couleur du rectangle change. Des commentaires ont été ajoutés au code pour une meilleure compréhension.

Exemple :       Copier le code

# Importer le module pygame
import pygame

# Importer la bibliothèque sys
import sys

# Initialiser pygame
pygame.init()

# Initialiser l'horloge pygame
clock = pygame.time.Clock()

# Définir la taille de la fenêtre
ecran_affichage = pygame.display.set_mode((500, 500))

# Ajouter le style et la taille de police
police_base = pygame.font.Font(None, 40)

# Stocker le texte saisi au clavier
texte_utilisateur = ''

# Définir la position et la taille du rectangle dans Pygame.Rect()
rect_input = pygame.Rect(200, 200, 140, 32)
couleur_active = pygame.Color("lightskyblue")
couleur_passive = pygame.Color("gray15")
couleur = couleur_passive

actif = False

while True:
	
	for event in pygame.event.get():
		if event.type == pygame.QUIT:
			pygame.quit()
			sys.exit()

		# Un clique avec la souris sur le rectangle,
		# le rendre actif
		if event.type == pygame.MOUSEBUTTONDOWN:
			if rect_input.collidepoint(event.pos):
				actif = True

		# Si une touche est enfoncée
		if event.type == pygame.KEYDOWN:
			if event.key == pygame.K_BACKSPACE:
				
				# Stocker le texte sans la dernière lettre
				texte_utilisateur = texte_utilisateur[0:-1]
			else:
				texte_utilisateur += event.unicode

	ecran_affichage.fill((0, 0, 0))

	if actif:
		couleur = couleur_active
	else:
		couleur = couleur_passive

	pygame.draw.rect(ecran_affichage, couleur, rect_input)
	
	# Rendre le texte
	surface_texte = police_base.render(texte_utilisateur, True, (0, 0, 0))
	ecran_affichage.blit(surface_texte, (rect_input.x + 5, rect_input.y + 5))
	rect_input.w = max(100, surface_texte.get_width() + 10)
	pygame.display.flip()
	clock.tick(60)

Afficher du texte dans la fenêtre de PyGame

Il y a 7 étapes de base pour afficher un texte sur la fenêtre de pygame :

  • 1. Créer un objet surface d'affichage en utilisant la méthode display.set_mode() de pygame.
  • 2. Créer un objet Font en utilisant la méthode font.Font() de pygame.
  • 3. Créer un objet surface texte, c'est-à-dire un objet surface dans lequel le texte est dessiné, en utilisant la méthode render() de l'objet police de pygame.
  • 4. Créer un objet rectangulaire pour l'objet surface texte en utilisant la méthode get_rect() de l'objet surface texte de pygame.
  • 5. Définir la position de l'objet rectangulaire en définissant la valeur de la propriété center de l'objet rectangulaire pygame.
  • 6. Copier l'objet surface texte dans l'objet surface d'affichage en utilisant la méthode blit() de l'objet surface d'affichage pygame.
  • 7. Afficher l'objet surface d'affichage sur la fenêtre pygame en utilisant la méthode display.update() de pygame.

Voici quelques exemples :

Exemple :       Copier le code

# Importation du module pygame dans ce programme
import pygame

# Activation de la bibliothèque pygame
# Initialisation de pygame et autorisation
# d'utiliser la fonctionnalité de pygame.
pygame.init()

# Définition de la valeur RGB pour les couleurs blanche,
# verte et bleue.
blanc = (255, 255, 255)
vert = (0, 180, 0)
bleu = (0, 0, 128)

# Attribution de valeurs aux variables X et Y
X = 400
Y = 400

# Création de l'objet de surface d'affichage
# avec des dimensions spécifiques (X, Y).
surface_affichage = pygame.display.set_mode((X, Y))

# Définition du nom de la fenêtre pygame
pygame.display.set_caption('Afficher du texte')

# Création d'un objet de police.
# Le 1er paramètre est le fichier de police
# présent dans pygame.
# Le 2ème paramètre est la taille de la police.
police = pygame.font.Font('freesansbold.ttf', 32)

# Création d'un objet de surface de texte,
# sur lequel le texte est dessiné.
texte = police.render('oujood.com ', True, vert, bleu)

# Création d'un objet rectangulaire pour
# l'objet de surface de texte.
rect_texte = texte.get_rect()

# Définition du centre de l'objet rectangulaire.
rect_texte.center = (X // 2, Y // 2)

# Boucle infinie
while True:

    # Remplissage complet de l'objet de surface
    # avec la couleur blanche
    surface_affichage.fill(blanc)

    # Copie de l'objet de surface de texte
    # vers l'objet de surface d'affichage
    # aux coordonnées du centre.
    surface_affichage.blit(texte, rect_texte)

    # Itération sur la liste d'objets d'événement
    # renvoyée par la méthode pygame.event.get().
    for event in pygame.event.get():

        # Si le type d'objet d'événement est QUIT
        # alors quitter pygame
        # et le programme.
        if event.type == pygame.QUIT:

            # Désactive la bibliothèque pygame
            pygame.quit()

            # Quitte le programme.
            quit()

    # Dessine l'objet de surface à l'écran.
    pygame.display.update()

Nous allons maintenant voir l'une des applications de l'affichage des textes, mais d'une manière différente, c'est-à-dire en faisant défiler le texte de 6 manières différentes dans la fenêtre de pygame.

  • 1. Faire défiler le texte en haut de l'écran.
  • 2. Défilement du texte en bas de l'écran.
  • 3. Défilement du texte sur le côté gauche de l'écran
  • 4. Défilement du texte sur le côté droit de l'écran
  • 5. Défilement du texte en diagonale de gauche à droite de l'écran
  • 6. Défilement du texte en diagonale du côté droit au côté gauche de l'écran.

Après avoir vu le code ci-dessous, vous pouvez mettre en œuvre votre propre modèle.

Exemple :       Copier le code

# Importation du module pygame dans ce programme
import pygame

# Activation de la bibliothèque pygame 
# Initialisation de pygame et autorisation
# d'utiliser les fonctionnalités de pygame
pygame.init()

# Création de l'objet surface d'affichage 
# (x, y) représente la hauteur et la largeur de la fenêtre pygame
win=pygame.display.set_mode((500, 500))

# Définition du nom de la fenêtre pygame
pygame.display.set_caption("Scrolling Text")

# Configuration du style de police pygame (1er paramètre)
# et de la taille de la police (2ème paramètre)
Font=pygame.font.SysFont('timesnewroman', 30)

# Définition des valeurs RGB pour les couleurs blanche,
# verte, jaune et orange
white=(255, 255, 255)
yellow=(255, 255, 0)
green=(0, 255, 255)
orange=(255, 100, 0)
done=False

# Séparation du texte en lettres 
# Le 3ème paramètre est la couleur de la police 
# et le 4ème paramètre est l'arrière-plan de la police
letter1=Font.render("H", False, orange, yellow)
letter2=Font.render("E", False, orange, green)
letter3=Font.render("M", False, orange, yellow)
letter4=Font.render("A", False, orange, green)
letter5=Font.render("N", False, orange, yellow)
letter6=Font.render("T", False, orange, green)
letter7=Font.render("H", False, orange, yellow)

# Attribution de valeurs aux variables i et c
i=0
c=1

# Boucle infinie
while not done:
	if(i>=820):
		i=0
		c+=1
		pygame.time.wait(500)
		
    # Remplissage complet de l'objet surface avec la couleur blanche
	win.fill(white)
	if(c%6==0): 
		# Défilement du texte en diagonale
        # du côté droit de l'écran.
        # Copie de l'objet surface du texte 
        # sur l'objet surface d'affichage 
        # aux coordonnées du centre.
		win.blit(letter1, (662-i, -162+i))
		win.blit(letter2, (639-i, -139+i))
		win.blit(letter3, (608-i, -108+i))
		win.blit(letter4, (579-i, -79+i))
		win.blit(letter5, (552-i, -52+i))
		win.blit(letter6, (529-i, -29+i))
		win.blit(letter7, (500 -i, 0 + i))
		i+=80
	if(c%6==5): 
		# Les autres cas de défilement du texte sont similaires...
        # (Cela dépend de la logique de défilement que vous souhaitez)
        # Dessine l'objet surface sur l'écran.
		win.blit(letter1, (-162+i, -162+i)) 
		win.blit(letter2, (-135+i, -135+i))
		win.blit(letter3, (-110+i, -110+i))
		win.blit(letter4, (-79+i, -79+i))
		win.blit(letter5, (-52+i, -52+i))
		win.blit(letter6, (-27+i, -27+i))
		win.blit(letter7, (0+i, 0+i))
		
		# Décide de la vitesse du texte à l'écran
		# du texte à l'écran
		i+=80
	if(c%6==4): 
	
		# Défilement du texte dans
		# droite de l'écran.
		win.blit(letter1, (480, -180+i))
		win.blit(letter2, (480, -150+i))
		win.blit(letter3, (480, -120+i))
		win.blit(letter4, (480, -90+i))
		win.blit(letter5, (480, -60+i))
		win.blit(letter6, (480, -30+i))
		win.blit(letter7, (480, 0+i))
		
		# Décide de la vitesse du texte à l'écran
		# du texte à l'écran
		i +=80
	if(c%6==3): 
		# Défilement du texte dans la partie gauche
		# gauche de l'écrann.
		win.blit(letter1, (0, -180+i))
		win.blit(letter2, (0, -150+i))
		win.blit(letter3, (0, -120+i))
		win.blit(letter4, (0, -90+i))
		win.blit(letter5, (0, -60+i))
		win.blit(letter6, (0, -30+i))
		win.blit(letter7, (0, 0+i))
		
		# Décide de la vitesse du texte à l'écran
		# du texte à l'écran
		i+=80
	if(c%6==1):

		win.blit(letter1, (-124+i, 0))
		win.blit(letter2, (-102+i, 0))
		win.blit(letter3, (-82+i, 0))
		win.blit(letter4, (-58+i, 0))
		win.blit(letter5, (-40+i, 0))
		win.blit(letter6, (-19+i, 0))
		win.blit(letter7, (0+i, 0))
		
		# Décide de la vitesse du texte à l'écran
		# du texte à l'écran
		i +=80
	if(c%6==2):
	
	# Scrolling the text in bottom of the Screen.
		win.blit(letter1, (-124+i, 470))
		win.blit(letter2, (-102+i, 470))
		win.blit(letter3, (-82+i, 470))
		win.blit(letter4, (-58+i, 470))
		win.blit(letter5, (-40+i, 470))
		win.blit(letter6, (-19+i, 470))
		win.blit(letter7, (0+i, 470))
		
		# Décide de la vitesse
		# du texte à l'écran
		i+=80
	
	# Dessine l'objet surface à l'écran.
	pygame.display.update()
	
	# itère sur la liste des objets Event 
	# qui a été retournée par la méthode pygame.event.get()
	for event in pygame.event.get():
		if(event.type==pygame.QUIT):
			done=True
	# Délai de 500 ms
	pygame.time.wait(500)
pygame.quit()



Voir aussi nos tutoriel :

fonction nl_langinfo

Rassemble des informations sur la langue et la configuration locale

la propriété border-bottom-right-radius

Définit la forme du coin bas  droit de la frontière

fonction quoted_printable_decode, quoted_printable_decode

Convertit une chaîne quoted-printable en chaîne 8 bits