Discussion :

[poiuy281]

Bonjour à tous,
je suis un élève en Terminale S, et j'aurais besoin de votre aide. Alors voila, je suis en spé ISN (informatique) et je dois créer un jeu pour la fin de l'année. Le seul problème est que mon programme d’après mon prof, me mène droit dans un mur et il me conseille donc de transformer le code en code s'apparentant à la programmation orientée objet(classes,self..), Mais le problème est que je ne sais pas du tout par ou commencer. Donc si vous pouviez juste me dire par ou commencer, ce serait génial. Merci beaucoup d'avance.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
 
import pygame
import random
from GIFImage import *
pygame.init()
fenetre = pygame.display.set_mode( (700,400), RESIZABLE )
pygame.display.set_caption("Twisted fates")
pygame.Surface((700,400))
imageLogo = pygame.image.load("logo.png")
imageLogo = pygame.transform.scale(imageLogo,(400,150))
imagejouer = pygame.image.load("Play.png")
imagejouer = pygame.transform.scale(imagejouer,(100,50))
imagecontrol = pygame.image.load("Controls.png")
imagecontrol = pygame.transform.scale(imagecontrol,(100,50))
background = pygame.image.load("fond.jpg")
imagebs = pygame.image.load("Best_scores.png")
imagebs = pygame.transform.scale(imagebs,(100,50))
imagecarre = pygame.image.load("Carre.png")
imagecarre = pygame.transform.scale(imagecarre,(100,3))
monde=pygame.image.load("Fond2.png")
imgMarcelineDroite = GIFImage("Marceline(normal).gif")
imgMarcelineStatique = pygame.image.load("MarcelineStatique.png")
imgMarcelineJump=pygame.image.load("Marceline(Jump).png")
imgMarcelineJumpGauche=pygame.image.load("Marceline(Jump)2.png")
imgMarcelineGauche=GIFImage("Marceline(2)(normal).gif")
imgMarcelineStatiqueGauche=pygame.image.load("Marceline(2)1.png")
imagebarre = GIFImage("ajax.gif")
imagecontrolecran = pygame.image.load("controlsecran.png")
imagecoeur = pygame.image.load("heart.png")
positionbackground=(0,0)
positionlogo = (150,0)
positionjouer = (325,125)
positionbs = (325,325)
positioncontrols = (325,225)
positioncarre= (325,175)
projectile=None
xMarceline = 10
yMarceline=322
mouvementMarceline = 0
xMonde=0
etapeSaut = -1
carre=0
modedejeu=1
loading = 0
a=0
direction = 0
 
 
def dessinermenu():
    global fenetre,imagejouer,imageLogo,background,positionbackground,imagebs,positionbs,imagecontrol,positioncontrols,imagecarre,positioncarre
    fenetre.blit(background,positionbackground)
    fenetre.blit(imageLogo,positionlogo)
    fenetre.blit(imagejouer,positionjouer)
    fenetre.blit(imagebs,positionbs)
    fenetre.blit(imagecontrol,positioncontrols)
    fenetre.blit(imagecarre,positioncarre)
    pygame.display.flip()
 
def dessinerchargement():
    global imagebarre,fenetre,background,positionbackground,loading,modedejeu
    fenetre.blit(background,positionbackground)
    imagebarre.render(fenetre,(325,175))
    loading=loading+1
    if loading==200:
        modedejeu=3
    pygame.display.flip()
 
def gererClavierEtSouris():
    global positioncarre,carre,continuer,i,positioncarre1,positioncarre2,modedejeu,loading
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            continuer = False
    touchesPressees = pygame.key.get_pressed()
    if touchesPressees[pygame.K_ESCAPE] == True:
        modedejeu = 1
        loading = 0
    if carre == 1:
        positioncarre = positioncarre1
    if carre == 2:
        positioncarre = positioncarre2
    if carre == 0:
        positioncarre = positioncarre
    sourisXY = pygame.mouse.get_pos()
    sourisBoutons = pygame.mouse.get_pressed()
    if 125<sourisXY[1]<175:
        if 325<sourisXY[0]<425:
            positioncarre = (325,175)
            if sourisBoutons[0]==1:
                modedejeu = 2
    if 225<sourisXY[1]<275:
        if 325<sourisXY[0]<425:
            positioncarre = (330,260)
            if sourisBoutons[0]==1:
                modedejeu = 4
    if 325<sourisXY[1]<375:
        if 325<sourisXY[0]<425:
            positioncarre = (330,355)
 
def controls():
    global fenetre,background,positionbackground,imagecontrolecran
    fenetre.blit(background,positionbackground)
    fenetre.blit(imagecontrolecran,(0,0))
    pygame.display.flip()
 
def modemenu():
    dessinermenu()
 
def calculerHauteurSaut(x):
    return int(((-1)*((x-8)*(x-8)))+64)
 
def dessinerjeu():
    ##On génère le monde.
    global monde,positionmonde, xMonde
    fenetre.blit(monde,(xMonde,0))
    ##On définit le scrolling et on le stoppe aux deux extrêmités de l'image.
    touchesPressees=pygame.key.get_pressed()
    if touchesPressees[pygame.K_RIGHT]== True and xMonde>-2800:
        xMonde=xMonde-4
        fenetre.blit(monde,(xMonde,0))
    if touchesPressees[pygame.K_LEFT]== True and xMonde<0: #On empêche le scrolling en arrière en début de monde.
        xMonde=xMonde+4
        fenetre.blit(monde,(xMonde,0))
    ##On place notre personnage dans le monde et on lui permet de sauter.
    global mouvementMarceline, xMarceline, imgMarcelineDroite, imgMarcelineStatique,yMarceline,modedejeu,loading,a,imgMarcelineJump, imgMarcelineStatiqueGauche, imgMarcelineGauche, Plateformes
    a=yMarceline-calculerHauteurSaut(etapeSaut)-18
    if mouvementMarceline == 0:
        if etapeSaut<0:
            fenetre.blit(imgMarcelineStatique, (xMarceline,a))
        elif etapeSaut>0:
            fenetre.blit(imgMarcelineJump,(xMarceline,a))
    elif mouvementMarceline == 1:
        if etapeSaut<0:
            imgMarcelineDroite.render(fenetre, (xMarceline,a))
        elif etapeSaut>0:
            fenetre.blit(imgMarcelineJump,(xMarceline,a))
    pygame.display.flip() #Rafraichissement complet de la fenêtre avec les dernières opérations de dessin.
    if 137<xMarceline<159 or 417<xMarceline<442 or 509<xMarceline<532:
        if yMarceline == 322:
            yMarceline=350
    else:
        yMarceline=322
    if a ==349:
        modedejeu = 1
        loading = 0
        xMarceline = 10
 
def ClavierEtSourisJeu():
    global continuer, xMarceline, mouvementMarceline, yMarceline, etapeSaut, imgMarcelineJump, direction, mouvementMarceline, xMarceline, imgMarcelineDroite, imgMarcelineStatique, imgMarcelineJump, imgMarcelineStatiqueGauche, imgMarcelineGauche
    ##On crée un bouton pour quitter la fenètre.
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            continuer = False
    ##On définit le déplacement.
    touchesPressees = pygame.key.get_pressed()
    if touchesPressees[pygame.K_RIGHT] == True:
        mouvementMarceline = 1
        xMarceline = xMarceline + 1
    elif touchesPressees[pygame.K_LEFT] == True:
        mouvementMarceline = 1
        xMarceline = xMarceline - 1
    else:
        mouvementMarceline = 0
    ##On permet d'afficher un personnage qui va soit vers la gauche soit vers la droite.
    if touchesPressees[pygame.K_LEFT]== True:
        imgMarcelineJump=imgMarcelineJumpGauche
        imgMarcelineStatique=imgMarcelineStatiqueGauche
        imgMarcelineDroite=imgMarcelineGauche
    elif touchesPressees[pygame.K_RIGHT]== True:
        imgMarcelineJump=pygame.image.load("Marceline(jump).png")
        imgMarcelineStatique=pygame.image.load("MarcelineStatique.png")
        imgMarcelineDroite=GIFImage("Marceline(normal).gif")
    ##On active le calcul des x pour permettre le saut.
    if touchesPressees[pygame.K_UP]==True and etapeSaut == -1:
        etapeSaut = 0
 
def modejeu():
    global etapeSaut
    ClavierEtSourisJeu()
    dessinerjeu()
    if etapeSaut >= 0: #Si etapeSsaut est >0, on saute. On va faire avancer etapeSaut pas à pas de 0 à 16.
        etapeSaut += 0.6
    if etapeSaut > 16:#Le saut étant fini, on réinitialise à etapeSaut=-1.
        etapeSaut = -1
clock = pygame.time.Clock()
continuer=True
while continuer:
    clock.tick(50)
    if modedejeu ==1:
        modemenu()
    if modedejeu == 2:
        dessinerchargement()
    if modedejeu == 3:
        modejeu()
    if modedejeu ==4:
        controls()
    gererClavierEtSouris()
    print (a)
    print (yMarceline)
pygame.quit()

[josmiley]

Ben le prof dit n'importe quoi ...

[Luke spywoker]

Ayant juste parcourus furtivement ton code.

Tu utilise des variables globales et des fonctions.

C.a.d tu utilise la programmation procédurale: basé sur des fonctions.

Alors il faut savoir que le type de base de python est l'objet. Tout élément que tu utilise est un objet: des séquences comme une liste, un string ou un tuple peu importe, c'est un objet.

Définition d'un objet: un objet possède des attributs et des méthodes en gros.

Par exemple une voiture a 4 roues, une couleur...
Ce sont des attributs.

Et des méthodes sont en faite des fonctions propre a ton objet.

Admettons que tu ai 4 attributs roues, et chaque roue est un objet de type 'Roue'.

La roue peut avoir comme attribut un diamètre, et un angle (orientation de la roue).

Alors tu comprendra que si la voiture a une méthode tourner a droite, il faudra agir sur les 2 roues de devants et changer l'angle de ces roues de 45 degrés vers la droite.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
#!/usr/bin/python
# -*- coding: utf-8 -*-
 
class Roue(object) :
  # Classe Roue calque pour créer des objets de type Roue.
 
  def __init__(self) :
    # méthode spéciale appeler constructeur permettant de définir 
    # les attributs par défaut de l'objet lors de sa création (instantiation). 
 
    self.diametre   = 60 # Attribut diametre de la roue.
    self.orientation = 0  # Attribut orientation de la roue. 
 
  def change_orientation(self, degrees) :
    # Méthode de la classe Roue prenant un argument pour changer l'orientationde la roue.
    self.orientation = degrees # l'argument change la valeur de l'attribut orientation de la roue.
 
class Voiture(object) :
  # Classe Voiture hérite de 'object' donc du type objet.
 
  def __init__(self,couleur) :
    # Constructeur avec un paramètre: couleur.
    self.couleur = couleur
 
    # Ici l'on instancie 4 objet de type Roue: 
    self.roue_avant_gauche   = Roue()
    self.roue_avant_droite   = Roue()
    self.roue_arriere_gauche = Roue()
    self.roue_arriere_droite = Roue()
 
  def tourner_droite(self) :
    # Méthode de la classe Voiture.
    self.roue_avant_droite.change_orientation(45) 
    self.roue_avant_gauche.change_orientation(45)
 
  def tourner_gauche(self) :
    # Méthode de la classe Voiture.
    self.roue_avant_droite.change_orientation(-45) 
    self.roue_avant_gauche.change_orientation(-45)
 
  def repreindre(self, couleur) :K_RIGHT
    # Méthode de la classe Voiture prenant un argument: 
    # la nouvelle couleur de la voiture.
    self.couleur = couleur 
 
# Instantiation de la classe Voiture (! la Majuscule)
# en un objet de type Voiture nommer par la variable voiture (! la Majuscule).      
voiture=Voiture("rouge")
 
# Appel de la méthode tourner_droite() de l'objet "voiture" (! la Majuscule). 
voiture.tourner_droite()
 
print "Orientation des roues de devant quand je tourne a droite."
 
print "Orientation roue avant gauche: %d" % voiture.roue_avant_gauche.orientation         
print "Orientation roue avant droite: %d" % voiture.roue_avant_droite.orientation 
 
# Appel de la méthode tourner_gauche() de l'objet "voiture" (! la Majuscule). 
voiture.tourner_gauche()
 
print "Orientation des roues de devant quand je tourne a gauche." 
print "Orientation roue avant gauche: %d" % voiture.roue_avant_gauche.orientation         
print "Orientation roue avant droite: %d" % voiture.roue_avant_droite.orientation 
 
# Appel de la méthode repeindre avec comme
# argument la nouvelle couleur.
 
print "Je repeint ma voiture." 
voiture.repreindre("vert")
 
print "j'ai repeint ma voiture en %s" % voiture.couleur

Le code c'est du python 2.*.* désolé je ne suis pas encore passé a python 3.*.*

Mais c'est tellement basique que tu devrai comprendre.

Note: j'ai fait exprès de compliquer pour te montrer que tout est objet.

Une liste possède les méthodes append(), pop(), etc...

Ton prof veut que tu recode ton programme en utilisant la P.O.O (Programmation Orienter Objet).
En le structurant avec des objets au lieu de tes fonctions et variables globales.

Mais normalement tu aurai dû suivre en cours sur la P.O.O.

Parce que si il n'y en pas eu:

Ben le prof dit n'importe quoi ...

d’après mon prof, me mène droit dans un mur et il me conseille donc de transformer le code en code s'apparentant à la programmation orientée objet(classes,self..), Mais le problème est que je ne sais pas du tout par ou commencer. Donc si vous pouviez juste me dire par ou commencer, ce serait génial.

Je t'assure que ton prof a raison car ça serai monter un mécanisme de pédale sur une voiture alors que l'on peut y mettre un moteur.
Comme moyen de locomotion (technique de programmation).
Même si ta trottinette marche elle ira pas loin.

Et je ne vais pas récrire ton programme a ta place, ça c'est ton job de programmeur.

Pour te motiver je te dirai que tu peut implémenter les classes que tu veut, laisse ton imagination te guider et peut-être un jours elle sera ta seule limite...

A toi de voir comment vont interagir tes objets: instances de classes.

Normalement pour les petits jeux: ont peut en définir qu'une seule, ce que je pense plus être de ton niveau.

Une classe principale Game(object).

*) Qui aurai une méthode switch_mode() pour changer de mode.

Conseil en passant: Pense a mettre des séparateur de mots underscores '_' dans tes noms de variables car elles sont difficilement lisibles.
Et tant que j'y suis: EN ANGLAIS. même si j'ai mis le code en français j'ai manquer a mes principes pour toi et la compréhension du code.
Ce ne sont que des conseils pour ton style c'est toi le programmeur.

*) Qui aurai une méthode display() servant a l'affichage en fonction du mode.

Il faut évidemment des structures conditionnelles piloté par des attributs, pour décider ce qui va être afficher ou non.

*) Qui aurai une méthode events_inputs() qui gère les entrées claviers et souris.

*) Puis une méthode mainloop() qui gère la boucle principale, qui doit évidemment appeler events_inputs() et display().

Mais c'est juste une idée de structuration, c'est toi le programmeur.

Je ne peut pas exécuter ton code car je n'ai pas pris la peine d'installer pygame pour python3, sur mon OS Linux (si tu est sous Windows je te conseille vivement d'en installer un, en dual-boot avec Windows: le choix de l'OS se fait au démarrage.).

Sur ce bon python a toi.