Comment définir les couleurs dans PyGame ?

Les couleurs dans pygame sont définies en RVB. Lorsque Pygame requiert une couleur, vous la transmettez sous la forme d’un tuple de trois entiers. Chacun représentera l’une des couleur rouge, vert et bleu. La valeur de chaque composant doit être comprise entre 0 et 255, où 255 correspond à la pleine intensité et 0 signifie que le composant ne contribue en rien à la couleur finale.

Les images sur l’ordinateur ont une résolution, par exemple, la résolution d’une image est de 800×600. Cela signifie que la largeur de cette image est de 800 pixels et la hauteur est de 600 pixels. C’est-à-dire qu’il y a 800 points au sens horizontal et 600 points au sens vertical. Ce qui nous donne, un total de 480 000 points qui couvrent toute notre image. En fait, ces points sont appelés pixels.

couleurs dans pygame

De ce fait, nous pouvons déterminer un emplacement sur notre image en utilisant ce principe. Les coordonnées du point du coin supérieur gauche sont (0,0), et le point le plus bas à droite sera (800 600). Donc (x, y) représente le point en pixel à l’horizontale et à la verticale en partant du point (0,0).

Comment définir une couleur dans une image ?

Un pixel représente une seule couleur qui est composée de trois couleurs, le rouge, le vert et le bleu. Donc, rouge, vert, bleu ou RVB pour faire court (RGB : red, green, blue). Les couleurs dans PyGame, sont représentées avec des tuples de trois entiers. La première valeur du tuple est la quantité de rouge dans la couleur. Une valeur de 0 signifie qu’il n’y a pas de rouge dans cette couleur, et une valeur de 255 signifie qu’il y a la quantité maximale de rouge dans la couleur. La deuxième valeur est pour le vert et la troisième valeur est pour le bleu.

CouleurRougeVertBleuTuple
Rouge25500(255, 0, 0)
Vert02550(0, 255, 0)
Bleu00255(0, 0, 255)

Par conséquent, en combinant ces trois valeurs, nous obtenons les couleurs de notre image.

Noir : (0, 0, 0)
Blanc : (255, 255, 255)
Jaune : (255, 255, 0)

Définir les couleurs dans Pygame

Nous allons prendre un exemple que je vous demande d’exécuter, puis nous expliquerons son fonctionnement. Le principe est de mapper (dictionnaire) certaines couleurs avec des touches claviers spécifiques. Lorsque vous appuyez sur le n par exemple, la fenêtre prendra une couleur noire et le j pour une couleur jaune, et ainsi de suite avec les autres couleurs.

import pygame as pyg
from pygame.locals import *

BLACK = (0, 0, 0)
WHITE = (255, 255, 255)

RED = (255, 0, 0)
GREEN = (0, 255, 0)
BLUE = (0, 0, 255)

YELLOW = (255, 255, 0)

C1_BLUE = (204, 204, 255)  # Un bleu personnalisée

key_dict = {K_n: BLACK, K_r: RED, K_v: GREEN, K_b: BLUE, K_j: YELLOW, K_l: WHITE}
print(key_dict)

screen = pyg.display.set_mode((800, 600))
bgColor = C1_BLUE
caption = 'La couleur RVB : ' + str(bgColor)
pyg.display.set_caption(caption)
screen.fill(bgColor)
pyg.display.update()

pyg.init()
running = True
while running:
    for pyEvent in pyg.event.get():
        if pyEvent.type == KEYDOWN:
            if pyEvent.key in key_dict:
                bgColor = key_dict[pyEvent.key]
                caption = 'La couleur RVB : ' + str(bgColor)
                pyg.display.set_caption(caption)
            else:
                bgColor = C1_BLUE

        if pyEvent.type == pyg.QUIT:
            running = False
        screen.fill(bgColor)
        pyg.display.update()

pyg.quit()

Nous avons commencé par importer la bibliothèque PyGame avec l’alias pyg. Puis nous importons un sous-module de PyGame qui est pygame.locals. Vous allez dire pourquoi ?

En fait, ça nous permettra d’utiliser les constantes de pygame.locals sans avoir besoin de les préfixer avec pygame. De plus, on place un ensemble limité de constantes et de fonctions dans l’espace de noms global de notre script.

Définir les couleurs.

BLACK = (0,0,0)
WHITE = (255,255,255)
 
RED = (255, 0, 0)
GREEN = (0, 255, 0)
BLUE = (0, 0, 255)
 
YELLOW = (255, 255, 0)
 
C1_BLUE = (204, 204, 255) # Un bleu personnalisée

Si vous regardez le code de RED = (255,0,0) , une variable est créée en tant que tuple. Dans la boucle d’événement principale, nous n’allons pas utiliser 255,0,0, et il est logique de remplacer cette valeur avec RED. Donc, définissez les couleurs à utiliser à l’avance au début de votre code source. Ou mieux encore, dans un autre module et importez-le.

Créer un dictionnaire qui mappe les touches du clavier avec les couleurs que nous avons définies précédemment. Vous vous souvenez des constantes de notre premier tutoriel sur PyGame ! Vous les trouverez dans les événements clavier.

key_dict = {K_n: BLACK, K_r: RED, K_v: GREEN, K_b: BLUE, K_j: YELLOW, K_l: WHITE}
print(key_dict)

Ce code vous donnera ceci dans la console :

{110: (0, 0, 0), 114: (255, 0, 0), 118: (0, 255, 0), 98: (0, 0, 255), 106: (255, 255, 0), 108: (255, 255, 255)}

En fait, 110 représente le code ASCII pour le n minuscule. C’est-à-dire le n du clavier correspond à la variable BLACK ou le noir est stocké dans la valeur n.

Passons au code suivant :

screen = pyg.display.set_mode((800, 600))
bgColor = C1_BLUE
caption = 'La couleur RVB : ' + str(bgColor)
pyg.display.set_caption(caption)
screen.fill(bgColor)
pyg.display.update()

pyg.init()

Tout d’abord, nous définissons le mode d’affichage (résolution) sur (800×600) px. La variable bgColor est utilisée pour définir la couleur d’arrière-plan. Puis nous utiliserons caption pour le titre de la fenêtre pygame. Ensuite, nous remplissons notre fenêtre avec la couleur d’arrière-plan en utilisant la fonction screen.fill.

Le gestionnaire des événements

Les événements des couleurs dans PyGame s’exécutent dans la boucle event.get() de la boucle for à l’intérieur de la boucle while.

running = True
while running:
    for pyEvent in pyg.event.get():
        if pyEvent.type == KEYDOWN:
            if pyEvent.key in key_dict:
                bgColor = key_dict[pyEvent.key]
                caption = 'La couleur RVB : ' + str(bgColor)
                pyg.display.set_caption(caption)
            else:
                bgColor = C1_BLUE

        if pyEvent.type == pyg.QUIT:
            running = False
        screen.fill(bgColor)
        pyg.display.update()

pyg.quit()
quit()

Lorsque event.get() se produit, des informations sur l’objet événement sont renvoyées. Vous pouvez savoir de quel type d’événement il s’agit en vérifiant le type.

KEYDOWN est une constante tirée de pygame.locals. En cas d’événement KEYDOWN, il est nécessaire de vérifier quelle touche a été enfoncée. Nous obtenons la valeur de la touche à partir du dictionnaire key_dict. Par exemple, si la touche r est enfoncée, RED = (255,0,0) est récupéré, puis affecté à l’arrière plan bgColor.

Remarquez que chaque couleur est affichée en haut dans la barre de titre de notre fenêtre. Si vous appuyez sur une touche qui ne se trouve pas dans le dictionnaire, vous aurez l’arrière plan par défaut.

À chaque changement de l’arrière plan, bgColor rempli notre fenêtre grace à la fonction fill(). Puis, il sera redessiné grâce à la fonction display.update().

La transparence dans une couleur

La transparence dans une couleur est connue sous le nom de valeur alpha. Lorsque vous dessinez un pixel sur un objet de surface, la nouvelle couleur remplace complètement la couleur existante. Mais avec les couleurs qui ont une valeur alpha, on ajoute simplement une teinte colorée à la couleur déjà présente. Vous obtenez une transparence en ajoutant une quatrième valeur au tuple des couleurs RVB.

Comment définir les couleurs dans PyGame ?

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée.

Retour en haut