TP - Récréatif - Création d'un jeu avec Processing

La structure de base

Commencer par enregistrer votre sketch ( nom générique donné aux programmes écrits dans Processing), sous le nom flappyFish.

Un dossier sera créé, dans lequel il y aura le fichier Processing (flappyFish.pyde).

Ce dossier est également accessible depuis l'interface de Processing ( Sketch/Afficher le dossier ).

Nous allons utiliser deux classes : fish et pipes

Création des fichiers fish.py et pipes.py

Cliquer sur le triangle d'ajout d'onglet.

Créer un nouvel onglet et nommer le : fish

Créer un nouvel onglet et nommer le : pipes

Nous avons donc 3 onglets 

Dans votre dossier, vous avez maintenant :

  • flappyFish.pyde

  • fish.py

  • pipes.py

et un fichier sketch.properties

Nous aurons également besoin de l'image du poisson..

Récupérer cette image et déposer la dans le dossier de votre sketch ( clic - droit et enregistrer l'image sous )

MéthodeLa fenêtre d'affichage

On utilise les deux fonctions de bases de Processing :

setup(), qui permet d'initialiser le programme

draw(), qui est une fonction qui s'exécute 60 fois par seconde ( d'où la possibilité de faire des animations)

Écrire ce code dans flappyFish.

1
def setup():
2
    size(640,320)#initialise une fenêtre de 640x320 pixels
3
4
def draw():
5
    background(0, 153, 204)# affiche la fenêtre avec une couleur de fond

Nous sommes prêts à développer le programme

MéthodeLa classe Fish

Dans cette classe, on définit des attributs qui localisent le poisson et qui permettent de gérer son déplacement

1
class Fish:
2
3
    def __init__(self):
4
        self.x = 50 #abscisse
5
        self.y = 240 #ordonnée
6
        self.r = 32 #taille
7
8
        self.gravity = 0.6 #pesanteur
9
        self.lift = -12 #acenseur 
10
        self.velocity = 0 #accélération 
Et des méthodes :
Pour charger l'image :
1
    def loadPic(self):
2
        self.pic = loadImage("poisson.png")
Pour aller vers le haut :
1
    def up(self):
2
        self.velocity += self.lift
Pour afficher l'image :
1
    def display(self):
2
        image(self.pic, self.x, self.y)
Pour actualiser l'affichage et ne pas sortir de la fenêtre :
1
    def update(self):
2
        self.velocity += self.gravity
3
        self.velocity *= 0.9
4
        self.y += self.velocity
5
        if (self.y >= height - self.r):
6
            self.y = height - self.r
7
            self.velocity = 0
8
        elif (self.y <= 0):
9
            self.y = 0
10
            self.velocity = 0
  • Écrire tout cela dans fish.py
  • Puis écrire le code ci-dessous dans flappyFish
  • Vérifier que tout fonctionne
1
from fish import Fish
2
3
fish = Fish()
4
5
def setup():
6
    size(640, 320)
7
    fish.loadPic()
8
9
def draw():
10
    background(0, 153, 204)
11
12
    fish.update()
13
    fish.display()
14
15
def keyPressed():
16
    if (key == " "):
17
        fish.up()
MéthodeLa classe Pipe
Voici la classe :
Votre travail : Expliquer le rôle des  attributs et des méthodes de cette classe
( vous commenterez le code pour l'expliquer )
1
class Pipe:
2
3
    def __init__(self):
4
        self.top = random(height) - 60
5
        if self.top < 60:
6
            self.top = 60
7
        if self.top > height - 180:
8
            self.top = height - 180
9
        self.bottom = height - self.top - 120
10
        self.x = width
11
        self.w = 40
12
        self.speed = 2
13
        self.hilite = False
14
15
    def display(self):
16
        fill(0, 125, 0)
17
        if self.hilite:
18
            fill(255, 0, 0)
19
        rect(self.x, 0, self.w, self.top)
20
        rect(self.x, height - self.bottom, self.w, self.bottom)
21
22
    def update(self):
23
        self.x -= self.speed
24
25
    def offscreen(self):
26
        if (self.x < -self.w):
27
            return True
28
        else:
29
            return False
30
31
    def collidesWith(self, otherObject):
32
        if ((otherObject.y < self.top) or (otherObject.y + otherObject.r > height - self.bottom)):
33
            if ((otherObject.x + otherObject.r > self.x) and (otherObject.x < self.x + self.w)):
34
                return True
35
        else:
36
            return False
MéthodeLe programme :
Compléter le programme flappyFish
1
from fish import Fish
2
from pipes import Pipe
3
4
fish = Fish()
5
pipes = []
6
7
def setup():
8
    size(640, 320)
9
    fish.loadPic()
10
    pipe = Pipe()
11
    pipes.append(pipe)
12
13
def draw():
14
    background(0, 153, 204)
15
16
    for i in range(len(pipes) - 1, -1, -1):
17
        if pipes[i].offscreen():
18
            pipes.pop(i)
19
        if pipes[i].collidesWith(fish):
20
            pipes[i].hilite = True
21
        else:
22
            pipes[i].hilite = False
23
        pipes[i].update()
24
        pipes[i].display()
25
26
    fish.update()
27
    fish.display()
28
29
    if (frameCount % 100 == 0):
30
        pipe = Pipe()
31
        pipes.append(pipe)
32
33
def keyPressed():
34
    if (key == " "):
35
        fish.up()
Faites le fonctionner...et commenter le ...
N'hésitez pas à modifier les variables pour  comprendre le programme.
En faisant quelques recherches sur Processing py , imaginer et réaliser de quoi faire un score
PrécédentPrécédentFin
AccueilAccueilImprimerImprimerRéalisé avec Scenari (nouvelle fenêtre)