Les exercices qui suivent peuvent être faits avec Pyzo ou avec pyxelstudio. Vous commencerez par créer un dossier nsi/chap1/td2 dans lequel les fichiers de ce td seront sauvegardés. Enregistrez un fichier par exercice et séparez chaque question par des commentaires (avec des ####).
Nous allons utiliser le module pyxel qui permet de faire des jeux vidéos retro en 2d.
Nous pouvons utiliser directement ce module en ligne à l'adresse : https://www.pyxelstudio.net ou dans Pyzo mais, dans ce cas, il
faut installer le module pyxel à l'aide de la commande : pip install pyxel.
Au lycée, l'installation n'est pas toujours possible en raison des autorisations sur les PC.
Pour tous les exercices utilisant pyxel, si vous avez utilisé pyxelstudio en ligne, une fois que vous avez vérifié que le code fonctionne, sauvegardez le fichier dans votre dossier nsi/chap1/td2.
Copier/coller le code suivant et remplacer les "." en répondant aux questions :
import pyxel
# Créer 5 variables de type integer définies par :
# x et y représentent la position du joueur (entier entre 0 et 127)
# couleur_joueur est la couleur du joueur (entier entre 0 et 15)
# couleur_fond est la couleur de fond (entier entre 0 et 15)
# cote est la taille du carré à dessiner (entier entre 1 et 127)
.
.
.
.
.
def update():
pass # ne fait rien pour l'instant...
def draw():
pyxel.cls(couleur_fond) # efface l'écran avec la couleur de fond
pyxel.rect(x, y, cote, cote, couleur_joueur) # dessine un carré
pyxel.init(128, 128, title="Version 1 - Variables")
pyxel.run(update, draw)
Copier/coller le code suivant et remplacer les "." en répondant aux questions :
import pyxel
# Créer 7 variables de différents types définies par :
# x et y représentent la position du joueur (entiers compris entre 0 et 128),
# Attention : le joueur doit partir en haut à gauche de la fenêtre.
# rayon de type int pour la taille du cercle à dessiner (initialisé à 10).
# pseudo de type str (nom du joueur).
# score de type str (score du joueur), intialisé à "0".
# couleur_joueur de type int pour représenter la couleur du joueur (entre 0 et 15)
# couleur_fond de type int pour la couleur de fond (entre 0 et 15)
.
.
.
.
.
.
.
def update():
global x, y # Utilisation et modification des variables x et y
# Exemple simple de mouvement :
# Incrémenter x et y à chaque tour pour simuler un mouvement "en diagonale vers le bas à droite".
.
.
def draw(): # Ne pas modifier cette fonction
pyxel.cls(couleur_fond)
# Concatener le pseudo et la chaîne "Joueur: " pour l'afficher,
# et l'affecter à la variable affiche_pseudo
.
pyxel.text(5, 10, affiche_pseudo, 7)
# Concatener le score et la chaîne "Score: " pour l'afficher,
# et l'affecter à la variable affiche_score
.
pyxel.text(5, 20, affiche_score, 7)
pyxel.circ(int(x), int(y), rayon, couleur_joueur)
pyxel.init(128, 128, title="Version 1.5 - Variables")
pyxel.run(update, draw)
# Question 1 : modifier update() pour que le joueur parte en bas à droite de la fenetre et se déplace en haut à gauche.
# Question 2 : modifier update() pour que le joueur parte à gauche au milieu de la fenetre et se déplace à l'horizontal à droite.
# Question 3 : ajouter une ligne à draw() pour que l'initiale du pseudo (1er caractère) soit affichée en bas à droite de la fenêtre.
# Question 4 : modifier update() pour que la couleur du joueur change à chaque déplacement. On mofifiera la ligne : global x, y, couleur_joueur
Copier/coller le code suivant et remplacer les "." en répondant aux questions :
import pyxel
# Créer 4 variables de type integer :
# x et y représentent la position du joueur (entiers entre 0 et 127),
# dx et dy sont les déplacements en x et y (entiers entre -127 et 127),
# dx et dy sont initialisées à 2 et 1 respectivement.
# Créer une variable booléenne en_jeu pour indiquer si le jeu est en cours,
# en_jeu est initialisée à True.
.
.
.
.
def update():
global x, y, dx, dy, en_jeu
if pyxel.btn(pyxel.KEY_SPACE):
en_jeu = False
# Mise à jour de la position du joueur
# Pour simuler un mouvement en diagonale
# On incrémente x et y par dx et dy
.
.
# Conditions simples avec if
# Si le joueur atteint le bord droit, on inverse la direction (dx devient négatif)
.
.
# Si le joueur atteint le bord gauche, on inverse la direction (dx devient positif)
.
.
# Si le joueur atteint le bord inférieur, on inverse la direction (dy devient négatif)
.
.
# Si le joueur atteint le bord supérieur, on inverse la direction (dy devient positif)
.
.
def draw():
pyxel.cls(0)
# Tester si le jeu est en cours
.
# Si en_jeu est True, afficher le cercle suivant :
# pyxel.circ(int(x), int(y), 10, 10) # le joueur est un cercle de rayon 10 pixels.
# Sinon, afficher "Le jeu est fini !" (et il n'y a plus d'animation)
.
# pyxel.text(30, 60, "Le jeu est fini !", 7)
pyxel.init(128, 128, title="Version 2 - conditions")
pyxel.run(update, draw)
# Question 1 : Compléter le code.
# Question 2 : Ajouter un rectangle de la couleur que vous voulez tout autour de la fenêtre de jeu de 5 pixels de large qui représente des murs. Vous utiliserez la fonction pyxel.rect(x, y, w, h, col) pour dessiner le rectangle. Le plus simple sera de dessiner en fait 4 rectangles (haut, bas, gauche, droite).
# Adapter les conditions pour que le joueur ne rentre pas dans le rectangle.
# Question 3 : Si on appuie sur la barre d'espace, le jeu change d'état : passe de fini à tourne ou de tourne à fini.
# Attention : utiliser pyxel.btnp() (et non pyxel.btn()) pour détecter uniquement l'instant où la touche est enfoncée,
# sinon l'état changera en boucle tant que la touche est maintenue.
Copier/coller le code suivant et remplacer les "." en répondant aux questions :
import pyxel
# Créer 4 variables de type integer
# x et y représentent la position du joueur (entiers entre 0 et 127)
# dx et dy sont les déplacements en x et y (entiers entre -127 et 127)
# dx et dy sont initialisées à 2 et 1 respectivement
.
.
.
.
def update():
global x, y, dx, dy
x += dx
y += dy
# Conditions complètes avec if/elif/else :
# Si le joueur atteint le bord droit, on inverse la direction (dx devient négatif),
# Sinon si le joueur atteint le bord gauche, on inverse la direction (dx devient positif),
# Sinon, on garde la direction actuelle :
.
.
.
.
.
.
# Si le joueur atteint le bord inférieur, on inverse la direction (dy devient négatif),
# Sinon si le joueur atteint le bord supérieur, on inverse la direction (dy devient positif)
# Sinon, on garde la direction actuelle :
.
.
.
.
.
.
def draw():
pyxel.cls(0)
pyxel.rect(x, y, 10, 10, 10) # le joueur est un carré de 10x10 pixels.
pyxel.init(128, 128, title="Version 2.5 - conditions")
pyxel.run(update, draw)
Reprendre le code de l'exercice 4 et le modifier en ajoutant la fonction draw_objet() pour
dessiner le joueur à la position (x, y). Appeler la fonction draw_objet() dans la fonction
draw().
Copier/coller le code suivant et remplacer les "." en répondant aux questions :
import pyxel
# Créer 5 variables :
# x et y pour la position,
# dx et dy pour la vitesse de déplacement du joueur
# x et y sont initialisées à 60, dx à 2, dy à 1
# et taille pour la taille du joueur (côté du carré)
# taille est initialisée à 10.
.
.
.
.
.
# Créer une fonction deplacer_joueur() pour mettre à jour la position du joueur.
# Elle prend en paramètre la taille du joueur, notée cote.
# La fonction utilise les variables x, y, dx et dy,
# la 1ère ligne de la fonction est : global x, y, dx, dy
# La fonction deplacer_joueur() met à jour x et y en ajoutant dx et dy respectivement.
# Elle doit aussi gérer les conditions pour que le joueur ne sorte pas de la fenêtre de jeu.
# Si le joueur atteint le bord droit, on inverse la direction (dx devient négatif).
# Si le joueur atteint le bord gauche, on inverse la direction (dx devient positif).
# Si le joueur atteint le bord inférieur, on inverse la direction (dy devient négatif).
# Si le joueur atteint le bord supérieur, on inverse la direction (dy devient positif).
# ATTENTION : il faut prendre en compte la taille du joueur pour les conditions !
# Par exemple, si le joueur a une taille de 10, il ne doit pas dépasser 128 - 10 = 118.
# Si le joueur a une taille de 20, il ne doit pas dépasser 128 - 20 = 108, etc.
.
.
.
.
.
.
.
.
.
.
.
.
# Créer une fonction draw_objet() pour dessiner l'objet joueur à la position (x, y).
# La fonction prend en paramètres la taille du joueur, qui est le côté du carré, noté cote,
# cote est un entier entre 1 et 127,
# et la couleur du joueur notée couleur_joueur,
# couleur_joueur est un entier entre 0 et 15.
# Le joueur est un carré de cote x cote pixels.
.
.
def update():
deplacer_joueur(taille)
def draw():
pyxel.cls(0)
draw_objet(taille, 9)
pyxel.init(128, 128, title="Version 3_1 - Fonctions")
pyxel.run(update, draw)
Copier/coller le code suivant et remplacer les "." en répondant aux questions :
import pyxel
# Créer 3 variables
# x et y pour la position et
# vitesse pour la vitesse de déplacement du joueur
# x et y sont initialisés à 60, vitesse à 2
.
.
.
def deplacer_joueur(): # Gestion des touches
global x, y
# Déplacement avec les touches
if pyxel.btn(pyxel.KEY_RIGHT) and x < 118:
x += vitesse
if pyxel.btn(pyxel.KEY_LEFT) and x > 0:
x -= vitesse
# en vous inspirant des 2 cas précédents, compléter le code pour pouvoir monter et descendre (KEY_UP et KEY_DOWN)
.
.
.
.
def draw_object():
# Affiche un rectangle aux coordonnées (x, y) de dimensions 10 x 10
.
def update():
deplacer_joueur()
def draw():
pyxel.cls(0)
draw_object()
pyxel.init(128, 128, title="Version 3.5 - Fonctions/Déplacement clavier")
pyxel.run(update, draw)
# Question 1 : Ajouter une variable taille pour la taille du joueur et modifier le code pour que le joueur
#soit un carré de taille x taille pixels.
# Question 2 : Modifier le joueur pour qu'il soit représenté par un cercle de rayon taille pixels.