Nuit du c0de
Nuit du c0de
En début de script, on importe le module Pyxel en lui donnant éventuellement un alias pour le manipuler plus facilement :
import pyxel # nécessitera de préfixer toutes les méthodes avec pyxel.nom_de_la_méthode
import pyxel as px # idem mais avec un alias raccourci !
On peut alors créer une fenêtre de jeu avec la méthode init, en lui passant les dimensions de la fenêtre, le titre, etc..( cf référence ) comme arguments.
L'unité de base dans Pyxel n'est pas le pixel écran : la fenêtre est divisée en "cases" de 8 x 8 pixels écran.
Ces "cases" seront quand même par la suite appelées pixels, plutôt que "pixels de Pyxel"...
Ces pixels sont adressables par leurs coordonnées dans la fenêtre.
L'origine (0, 0) du repère est en haut à gauche de la fenêtre; les abscisses augmentent donc vers
la droite, et les ordonnées vers le bas.
import pyxel
pyxel.init(128, 128, title="Super Jeu") # créé une fenêtre de 128x128 pixels ( fond noir par défaut )
Pour "faire tourner" le jeu, il faut alors écrire deux fonctions :
update() dont le rôle sera de modifier les variables qui gèrent le mouvement des différents sprites, du décor, etc...draw() qui sera chargée de dessiner effectivement les sprites dans la fenêtre du jeu.cls(couleur) ( un peu bourrin, mais Pyxel ne propose pas d'autre méthode...)Pour "lancer" le jeu à proprement parler, on utilisera alors la méthode run(), qui appellera périodiquement ( par défaut, 30 fois par seconde) et "en boucle" les deux fonctions update() et draw() :
import pyxel
pyxel.init(128, 128, title="Super Jeu")
def update():
'''Modifie les variables gérant le déplacement des sprites, du décor'''
pass
def draw():
'''Dessine les éléments du jeu dans la fenêtre'''
pyxel.cls(0) # efface la fenêtre ( ici avec la couleur noire, celle par défaut )
pass
pyxel.run(update, draw) # lance le jeu. DOIT ÊTRE LA DERNIÈRE INSTRUCTION DU SCRIPT !
On ne peut pas passer d'arguments à ces deux fonctions; ce n'est pas un problème pour la fonction draw() qui se contentera de lire des variables définies en dehors de sa portée,
ce qui ne pose pas de problème.
Par contre, la fonction update() va devoir modifier des variables qui seront définies en dehors de sa portée ( souvent dans le programme principal )
Pour cela, vous serez obligés, dans la fonction update() ( et dans chaque autre fonction concernée ! ) d'indiquer quand vous aurez besoin de modifier des variables globales
au script, c'est à dire qui seront en fait les mêmes partout dans le jeu ( donc non locales à une fonction ).
On préfixe ces variables par le mot clé global à l'intérieur des fonctions.
Voila par exemple une animation qui "fait rebondir" une balle sur les "parois" de la fenêtre :
import pyxel
pyxel.init(128, 128, title="Super Jeu")
def update():
global x, y, vx, vy # NÉCESSAIRE CAR ON VEUT MODIFIER CES VARIABLES, DÉFINIES EN DEHORS DE LA FONCTION
# Gestion des rebonds sur les parois : on inverse le sens de déplacement
if x < 1 or x > 127: # Bords verticaux ( gauche et droite )
vx = - vx
if y < 1 or y > 127: # Bords horizontaux ( haut et bas )
vy = - vy
# Mise à jour des coordonnées de la balle
x = x + vx
y = y + vy
def draw():
# Inutile d'indiquer x et y comme globales, même si elle sont définies hors de la fonction, car on se contente ici de les lire
pyxel.cls(0)
pyxel.circ(x, y, 2, 8)
########################
# PROGRAMME PRINCIPAL #
########################
# Coordonnées initiales de la balle
x = 50
y = 10
# Sens de déplacement initial de la balle
vx = 1
vy = 1
# Lancement du jeu
pyxel.run(update, draw)
Le problème est que, lorsque votre jeu impliquera plusieurs "acteurs" à modifier/animer, vous vous retrouverez alors avec un très grand nombre de variables à déclarer comme globales, ce qui est une pratique à éviter car source de confusion !
Un des moyens pour éviter cela est d'écrire une paire de fonctions de modification/affichage pour chaque acteur, ces fonctions étant alors appelées, pour chaque "acteur", depuis les fonctions
update() et draw() :
import pyxel
pyxel.init(128, 128, title="Super Jeu")
############################
# FONCTION GÉRANT LA BALLE #
############################
def bouge_balle():
global x, y, vx, vy
# Gestion des rebonds sur les parois : on inverse le sens de déplacement
if x < 1 or x > 127: # Bords verticaux ( gauche et droite )
vx = - vx
if y < 1 or y > 127: # Bords horizontaux ( haut et bas )
vy = - vy
# Mise à jour des coordonnées de la balle
x = x + vx
y = y + vy
def affiche_balle():
pyxel.circ(x, y, 2, 8)
##################
# GESTION DU JEU #
##################
def update():
bouge_balle()
def draw():
pyxel.cls(0)
affiche_balle()
########################
# PROGRAMME PRINCIPAL #
########################
# Coordonnées initiales de la balle
x = 50
y = 10
# Sens de déplacement initial de la balle
vx = 1
vy = 1
# Lancement du jeu
pyxel.run(update, draw)
Cette façon de faire structurera votre code et permettra également de mieux vous répartir le travail ( en attendant d'utiliser la POO comme vos camarades de Terminale...)
Le concept "retro" de Pyxel fait que la palette de couleurs est réduite à 16.
On indique une couleur par un numéro ( de 0 à 15 ) dans la palette.
Voir la référence Pyxel pour la palette de couleurs par défaut; il est possible de modifier cette palette :
org_colors = pyxel.colors.to_list() # récupère les couleurs dans une liste
pyxel.colors[15] = 0x112233 # modification de la couleur d'indice 15 en donnant une valeur RGB sur 24 bits en hexadécimal ( 0xrrggbb )
pyxel.colors.from_list(org_colors) # met à jour la palette de couleur
Il est possible de dessiner dans la fenêtre :
Voir la référence pour les méthodes correspondantes.
Il est bien entendu aussi possible de dessiner des images stockées dans des banques d'images ( il y 3 banques différentes possible).
Voir plus loin pour leur utilisation.