I-Scryper a écrit:

Mais dans ma fonction verifier() il y a pourtant un if qui ne supprime l'obus QUE si il atteind les bords.

Oui, mais à la ligne précédente tu fais:

self.x1_ob, self.y1_ob, self.x2_ob, self.y2_ob = self.Canv.coords(self.obus)

Or si l'obus n'existe plus, comment peut-on récupérer ses coordonnées? 

I-Scryper a écrit:

C'est normal de rencontrer autant d'erreur dans un projet qui n'est pourtant pas quelque chose d'immense ? 

C'est pas anormal. Faut juste y aller par étape. Par exemple pour créer ta fonction trajectoire, tu n'a pas besoin de l'entièreté de ton code. Tu peux juste créer un code minimal pour voir si ton boulet apparaît quand tu appuie sur un bouton, suis la trajectoire (avec un angle prédéfini pour le début) et se supprime quand il arrive sur les bords. Une fois ça fait, ça sera beaucoup plus facile à incorporer dans ton projet car tu l'aura déjà validé sur un plus petit code 

Olygrim a écrit:

I-Scryper a écrit:

Mais dans ma fonction verifier() il y a pourtant un if qui ne supprime l'obus QUE si il atteind les bords.

Oui, mais à la ligne précédente tu fais:

self.x1_ob, self.y1_ob, self.x2_ob, self.y2_ob = self.Canv.coords(self.obus)

Or si l'obus n'existe plus, comment peut-on récupérer ses coordonnées? 

Mais normalement, lorsque l'obus est détruit, je dois avoir 'détruit' en output. C'est dans le if de verifier(). Et comme je n'ai que 'hf' en output, ça signifie qu'il n'a JAMAIS été détruit...

Et pour mes deux autres problèmes ? (voir mon message précédent)

Merci !

Tu as tous les points qui sont dessinés car la ligne 4 de ta fonction feu créé un nouvel obus à chaque itération. Après c'est difficile de comprendre ton code car tu as trop de variables (self.x, self.X, self.x1, self.y, self.Y, self.y1, self.t, self.tmax, self.temps), ...

Normalement, il n'y a qu'une seule paire de coordonnées à avoir: les coordonnées du boulet (self.x, self.y). Voilà une représentation que je pense un peu plus logique:

#Attributs à mettre dans la méthode '__init__'
self.r = 5
self.t = 0
self.dt = 5


def feu(self) :

    if self.t == 0:
        #Création du boulet
        self.obus = self.Canv.create_oval(self.x1 + self.r, self.y1 + self.r,
                                          self.x2 - self.r, self.y2 - self.r,
                                          fill="black")
    
    self.y = #le calcul pour connaître la nouvelle ordonnée du boulet
    self.x = #le calcul pour connaître la nouvelle abscisse du boulet
    

    #verifier devrait simplement renvoyer un booléen ('True' ou 'False')
    if verifier():
        #MAJ de l'affichage
        self.Canv.coords(self.obus, self.x + self.r, self.y + self.r,
                                    self.x - self.r, self.y - self.r)
        self.Canv.update()
        
        #Incrémentation de t et réactivation de la fonction
        self.t += self.dt
        self.fen.after(self.dt, self.feu)
    
    else:
        self.t = 0
        #suppression de l'obus ici (et non dans 'verifier')
        self.Canv.delete(self.obus)

C'est juste une représentation, donc il peut y a voir des erreurs 

EDIT: Et tu vois, on pourrait même se passer de la méthode verifier en mettant directement les deux lignes nécessaires dans ce code:

#À mettre à la place de la ligne 20 de mon code
self.x1_ob, self.x2_ob, self.y1_ob, self.y2_ob = self.Canv.coords(self.obus)
if self.x1_ob == 0 or self.y1_ob == 0 or self.x2_ob == self.x1 or self.y2_ob == self.y1:

-
Edité par Olygrim 11 mars 2017 à 9:07:45

D'accord je vais voir ça. Mais que représente self.dt ?

Ici ça représente deux choses:

• C'est le temps (en s) que tu ajoutes à self.t à chaque itération (ça correspondait à 0.004 dans ton code)
• C'est le temps (en milli-seconde) à mettre en argument de after

J'ai changé les formules, pour des plus simples, mais ça fonctionne toujours de la même manière (je veux dire la démarche de feu ne change pas). Par contre, je n'ai pas de courbe, j'ai un espèce d'ovale qui se forme à chaque fois.

Tu n'aurais pas la solution pour ça ?

La fonction maintenant :

    def feu(self) :
        """Fonction pour tirer l'obus."""
        r = 5
        self.obus = self.Canv.create_oval(self.x1 + r, self.y1 + r, self.x2 - r, self.y2 - r, fill = "black")
        self.tmax = 1
        if self.t <= self.tmax :
            self.X = sqrt(500) * cos(self.ang)
            self.Y = -0.5 * 9.81 * t**2 + sqrt(500) * sin(self.ang)
            self.t += 0.004
        else :
            self.t = 0
            self.continuer = False
        self.Canv.coords(self.obus, self.X + r, self.Y + r, self.X - r, self.Y - r)
        self.Canv.update()
        self.verifier()
        self.fen.after(10, self.Canv.delete(self.obus))
        if self.continuer :
            self.temps = 2
            self.fen.after(self.temps, self.feu)

Merci !

EDIT : dès que ça fonctionnera, je simplifierais mes fonctions comme tu l'as proposé.

-
Edité par I-Scryper 15 mars 2017 à 19:05:31

Le problème c'est que ta ligne 4 est mal placée car elle se trouve au niveau de la fonction et donc à chaque fois que tu appelles feu (ligne 19) tu vas recréer à chaque itération ton obus. Si tu regardes mon précédent code, j'ai mis sa création dans un if (ce qui fait qu'il est créer qu'UNE SEULE FOIS ).

Ensuite, que fait la ligne 16?? . Pas sûr que ça fonctionne (et je vois pas pourquoi la suppression est dans la méthode after).

Même chose, que fait ce self.verifier tout seul? Il serait plus logique de s'en servir pour faire le déplacement et la suppression (comme dans mon précédent code).

D'accord je vais voir ça.

Pour la ligne 16, je viens de me rendre compte que nohar avait totalement raison quand il a dit :

L'apprentissage de la programmation est un cycle sans fin, on découvre un marteau, on apprend à s'en servir, puis tout devient un clou et on essaye de tout régler à coups de marteau, évidemment au bout d'un moment c'est plus du tout adapté et on se vautre, puis on decouvre un tournevis, tout devient une vis, on résoud tout à coups de tournevis, on finit par se rendre compte que ça marche pas partout, puis on découvre un rouleau de scotch, etc.

Je vais arranger ça 

Olygrim a écrit:

Même chose, que fait ce self.verifier tout seul? Il serait plus logique de s'en servir pour faire le déplacement et la suppression (comme dans mon précédent code).

Regarde ce que j'ai mis dans mon EDIT au post précédent 

-
Edité par I-Scryper 16 mars 2017 à 19:37:33

Alors voilà,

J'ai travaillé sur ma fonction en reprenant le modèle que tu m'avais donné. Voici ma fonction actuelle :

    def feu(self) :
        """Fonction pour tirer l'obus, vérifier qu'il ne touche pas les bords"""
        #et créer l'animation d'explosion de l'obus""" --> pour plus tard
        r = 5
        if self.t == 0 :
            self.obus = self.Canv.create_oval(self.x1 + r, self.y1 + r, self.x2 - r, self.y2 - r, fill = "black")
        self.tmax = 1
        if self.t <= self.tmax :    # tant que t ne dépasse pas tmax, les nouvelles coordonnées du boulet sont calculées
            self.x = sqrt(500) * cos(self.ang)
            self.y = -0.5 * 9.81 * self.t**2 + sqrt(500) * sin(self.ang)
            self.X = 250 * self.x + 250
            self.Y = -250 * self.y + 250
            self.t += 0.004
        else : # si t dépasse tmax, on remet t à 0 et on passe la valeur de continuer à False pour stopper le lancement de la fonction
            self.t = 0
            self.continuer = False
        # MàJ de l'image
        self.x1_ob, self.y1_ob, self.x2_ob, self.y2_ob = self.Canv.coords(self.obus) # récupération des coordonées de l'obus
        if self.x1_ob == 0 or self.y1_ob == 0 or self.x2_ob == self.x1 or self.y2_ob == self.y1 :
            self.Canv.delete(self.obus)  # si l'obus touche un bord, il est détruit
            print("detruit")
        else :
            print(self.x1_ob, self.y1_ob, self.x2_ob, self.y2_ob) # print de vérification (à supprimer)
            self.Canv.coords(self.obus, self.X + r, self.Y + r, self.X - r, self.Y - r)
            self.Canv.update()
        self.Canv.delete(self.obus)
        if self.continuer :
            self.temps = 10
            self.fen.after(self.temps, self.feu)

Le truc c'est que j'obtiens ça en output :

Traceback (most recent call last):

  File "C:\Users\xxxxx\Desktop\Florian\EduPython\App\lib\tkinter\__init__.py", line 1538, in __call__

    return self.func(*args)

  File "C:\Users\xxxxx\Desktop\Florian\EduPython\App\lib\tkinter\__init__.py", line 587, in callit

    func(*args)

  File "C:\Users\xxxxx\Desktop\Florian\EduPython\App\Lib\MesModules\canon.py", line 63, in feu

    self.x1_ob, self.y1_ob, self.x2_ob, self.y2_ob = self.Canv.coords(self.obus) # récupération des coordonées de l'obus

ValueError: need more than 0 values to unpack

Donc je me suis dit que peut être il pense que l'obus n'existe déjà plus ? Pourtant la ligne de destruction de l'obus est dans un bloc if et j'ai essayé en la le delete en commentaire mais j'obtiens la même chose. Donc pour le moment j'aurais besoin d'aide la dessus.

Merci ! 

Oui, c'est encore une fois normal. Effectivement la suppression de l'obus se trouve dans un bloc if (ligne 20), mais pas la récupération des coordonnées (ligne 18).

Donc imaginons que ton obus sorte de la zone AVANT que t soit égale à tmax. continuer étant toujours égal à True, la fonction sera relancée. Or le boulet n'existe plus car il a été supprimé à l'itération précédente (celui-ci est supprimé non pas quand t atteint tmax mais quand il sort de la zone).

Mais je ne comprend pas du tout ta logique. Pourquoi vouloir ABSOLUMENT rajouter tmax. À quoi sert-il à part t'embrouiller? Il est totalement inutile. De même à quoi sert la variable continuer. Encore une fois, c'est rajouter des éléments qui ne sont pas nécessaire et qui complexifie le code inutilement.

La seule chose indispensable dans ce code, c'est la vérification des coordonnées. C'est le cœur de cette fonction et c'est elle qui devrait dire les actions à effectuer (est-ce qu'on relance la fonction? est-ce qu'on met à jour l'affichage? est-ce qu'on supprime le boulet? est-ce qu'on recalcule les coordonnées? -> tout ça dépend UNIQUEMENT de ce que va dire la vérification des données). Et c'est exactement ce que faisait le code que je t'ai proposé précédemment (il faut juste le compléter pour calculer les nouvelles coordonnées du boulet):

def feu(self) :
 
    if self.t == 0:
        self.obus = self.Canv.create_oval(self.x1 + self.r, self.y1 + self.r,
                                          self.x2 - self.r, self.y2 - self.r,
                                          fill="black")
    
    self.y = #A calculer
    self.x = #A calculer
    
    if verifier():
        self.Canv.coords(self.obus, self.x + self.r, self.y + self.r,
                                    self.x - self.r, self.y - self.r)
        self.Canv.update()
         
        self.t += self.dt
        self.fen.after(self.dt, self.feu)
    
    else:
        self.t = 0
        self.Canv.delete(self.obus)

• Les lignes 3 et 4 c'est pour l'initialisation du boulet (quand t = 0)
• Les lignes 8 et 9, calcul des nouvelles coordonnées du boulet
• Ligne 11: le cœur de la fonction. verifier est censé renvoyer un booléen pour dire si l'obus est toujours dans le cadre
• Lignes 12 à 17: Si c'est la cas, alors on fait les actions nécessaire (affichage, incrémentaion de t, relance de la fonction)
• Lignes 20 et 21: Si ce n'est pas le cas, on supprime l'obus et on réinitialise le compteur.

Est-ce que cette fonction marche? -> je ne sais pas (ne l'ayant pas testée). Par contre, son déroulement est lo-gi-que. Il n'y a pas de variables parasites, juste le nécessaire. Et les actions sont gérées par la vérification de la position de l'obus. Ce qui est logique car c'est ça qui détermine si l'obus doit être supprimé ou pas.

Pour tmax, à la base c'est la valeur à partir de laquelle je dois arrêter de calculer x et y. C'est ce qu'on m'avait donné dans le forum physique, mais je l'ai modifiée et c'est vrai qu'après réflexion, elle a perdu son sens.

Pour le reste, c'est vrai que ton code est plus logique que le mien mais j'ai toujours eu l'impression qu'il était logique. Et il l'est c'est juste que je complique les choses (tu me l'avais déjà fait remarqué dans un autre topic )

Je vais voir ça et je reviendrai vers toi en cas de problème. Donc sois sûr que je vais éditer ce message dans les minutes/heures à venir.

Merci ! 

EDIT : alors...pour faire bref je t'ai fait perdre beaucoup de temps...Donc en suivant ce que tu m'as dit j'ai codé ça :

    def verifier(self) :
        self.x1_ob, self.y1_ob, self.x2_ob, self.y2_ob = self.Canv.coords(self.obus) # récupération des coordonées de l'obus
        if self.x1_ob <= 0 or self.y1_ob <= 0 or self.x2_ob >= 500 or self.y2_ob >= 500 :
            print("detruit")
            return False
        else :
            print("hf")
            return True

    def feu(self) :
        """Fonction pour tirer l'obus, vérifier qu'il ne touche pas les bords"""
        #et créer l'animation d'explosion de l'obus""" --> pour plus tard
        r = 5 # rayon de l'obus
        if self.t == 0 :
            self.obus = self.Canv.create_oval(self.x1 + r, self.y1 + r, self.x2 - r, self.y2 - r, fill = "black")

        self.y = -(1/2) * (9.81/(500)*(cos(self.ang)**2)) * (self.t**2) + (tan(self.ang) * self.t)
        self.X = (self.x1 * self.t ) + self.x1
        self.Y = -self.x1 * self.y + self.x1

        # MàJ de l'image
        if self.verifier() :
            print(self.x1_ob, self.y1_ob, self.x2_ob, self.y2_ob) # print de vérification (à supprimer)
            self.Canv.coords(self.obus, self.X + r, self.Y + r, self.X - r, self.Y - r)
            self.Canv.update()
            self.t += 0.004
            self.temps = 10
            self.fen.after(self.temps, self.feu)
        else :
            self.Canv.delete(self.obus)  # si l'obus touche un bord, il est détruit
            self.t = 0

Tu remarqueras que la ligne 3 n'est plus la même qu'avant. En fait pendant les mois où verifier m'a posé problème c'est parce que j'ai mis self.x1 et self.y1 à la place de 500. Les deux coordonnées sont en fait 2 des coordonnées de...mon canon. Et 500 c'est les bords de mon canvas (largeur et hauteur). Donc en fait je me suis juste trompé là...

Du coup maintenant ça fonctionne.

Désolé pour le temps perdu et merci quand même pour ton aide !

Donc maintenant, le seul problème c'est qu'il ne part quasiment jamais dans la bonne direction...

-
Edité par I-Scryper 24 mars 2017 à 18:49:19

I-Scryper a écrit:

Donc maintenant, le seul problème c'est qu'il ne part quasiment jamais dans la bonne direction...

Ton angle, tu l'as convertit en radian?

Oui, tu peux le voir à la ligne 23 du premier post de ce sujet.

En fait, il ne part jamais dans la bonne direction sauf pour 0 et 360° et ne pars JAMAIS vers la gauche du graphique.

Merci !

Tu t'es peut-être trompé dans ton équation du mouvement. Pourquoi divises-tu par 500? Est-ce pour mettre à l'échelle? Si oui, pourquoi ne pas diviser x aussi par 500? D'ailleurs pourquoi as-tu une variable y mais pas x?

Encore une fois, tu es sûrement en train de complexifier inutilement. Je ne vois pas pourquoi tu aurais autant de variables: x, X, y et Y. Une seule paire suffit, celle des coordonnées du boulet.

PS: Il me semble que ton équation n'est pas homogène. C'est-à-dire qu'il faut additionner des valeurs qui ont les mêmes unités. Dans X par exemple, tu additionnes un temps * une distance avec une distance:

self.X = (self.x1 * self.t ) + self.x1
   ^         ^         ^          ^
   m         m         s?         m

Idem avec y. y étant une distance (unité le m), il faut que chaque bloc du côté droit soit équivalent à une distance (en terme d'unité). J'ai pas l'impression que ce soit le cas.

Le plus simple serait d'aller sur le forum de physique pour qu'il t'aide à écrire ces équations.

Olygrim a écrit:

Tu t'es peut-être trompé dans ton équation du mouvement. Pourquoi divises-tu par 500? Est-ce pour mettre à l'échelle? Si oui, pourquoi ne pas diviser x aussi par 500? D'ailleurs pourquoi as-tu une variable y mais pas x?

500 c'est la vitesse au carré. Ou la force.

Parce qu'il m'a donné la formule pour f(x) (donc y) et rien d'autre. Donc je ne peux pas calculer x et y vu que je n'ai qu'une seule formule.

Olygrim a écrit:

Encore une fois, tu es sûrement en train de complexifier inutilement. Je ne vois pas pourquoi tu aurais autant de variables: x, X, y et Y. Une seule paire suffit, celle des coordonnées du boulet.

PS: Il me semble que ton équation n'est pas homogène. C'est-à-dire qu'il faut additionner des valeurs qui ont les mêmes unités. Dans X par exemple, tu additionnes un temps * une distance avec une distance:

self.X = (self.x1 * self.t ) + self.x1
   ^         ^         ^          ^
   m         m         s?         m

Parce qu'il m'a donné la formule pour f(x) (donc y) et rien d'autre. Donc je ne peux pas calculer x et y vu que je n'ai qu'une seule formule.

Et dans un exercice fait il y a quelques moi, je devais dessiner des courbes paramétrées dans un graphique, et j'ai regardé un peu commentla solution était faite pour avoir une idée de comment faire et c'était fait ainsi.

Olygrim a écrit:

Le plus simple serait d'aller sur le forum de physique pour qu'il t'aide à écrire ces équations.

C'est ici que j'ai demandé la formule. Plus aucune réponse depuis le 3 décembre...

-
Edité par I-Scryper 29 mars 2017 à 16:47:55

Du coup je fais comment ? Je ne compte pas abandonner le projet pour ça.

I-Scryper a écrit:

Du coup je fais comment ?

Bah il faut que tu cherches les formules pour le mouvement de ton boulet. Et je te laisse faire cette étape.

J'ai cherché dans mon syllabus, pour voir comment ils ont fait (c'est la seule fois où j'ai regardé dedans pour m'aider). Et donc voici ma fonction feu(), elle n'a pas beaucoup changé par rapport à la version d'avant :

    def feu(self) :
        """Fonction pour tirer l'obus, vérifier qu'il ne touche pas les bords"""
        #et créer l'animation d'explosion de l'obus""" --> pour plus tard
        r = 5 # rayon de l'obus
        if self.creer :
            self.obus = self.Canv.create_oval(self.x1 + r, self.y1 + r, self.x2 - r, self.y2 - r, fill = "black")
            # Composantes verticales et horizontales de la vitesse de l'obus :
            self.cv = -15 * sin(self.ang)
            self.ch = 15 * cos(self.ang)
            self.creer = False
        # MàJ de l'image
        if self.verifier() :
            print(self.x1_ob, self.y1_ob, self.x2_ob, self.y2_ob) # print de vérification (à supprimer)
            self.Canv.move(self.obus, self.ch, self.cv)
            #self.Canv.coords(self.obus, self.ch + r, self.cv + r, self.ch - r, self.cv - r)
            self.Canv.update()
            self.ch += .5
            self.augmentationCV += .5
            self.cv += self.augmentationCV
            self.temps = 10
            self.fen.after(self.temps, self.feu)
        else :
            self.Canv.delete(self.obus)  # si l'obus touche un bord, il est détruit
            self.augmentationCV = 0
            self.creer = True

Le truc, c'est que quand je mets la ligne 15 en commentaire et que je retire le # devant la ligne 14 , j'ai comme avant mais en mieux : le boulet ne part pas toujours dans la bonne direction mais il part vers la gauche et la droite du graphique. Mais je n'ai plus un cercle, mais un ovale. Par contre les courbes sont assez bizzares.

Et quand je fais l'inverse, il me détruit l'obus directement alors que les coordonnées de l'obus n'ont pas dépassées les coordonnées max.

Je vais maintenant chercher de l'aide sur d'autres forums (pas sur OC vu que je n'ai pas de réponse...), mais si jamais tu sais m'aider un peu la dessus ?

Merci !

Bonjour,

Le problème a été résolu, donc j'ai pensé à quelque chose.

Quand la musique a finie d'être jouée, au lieu de choisir une musique manuellement, est-ce qu'il est possible de créer une playlist automatique ? Parce que si par exemple, dans le mode solo que je compte ajouter plus tard, une concentration extrême est requise () pour réussir un niveau, on risque de perdre la partie à cause du fait que l'on change la musique...

J'ai donc pensé a créer une fonction pour ça mais j'ai besoin de :

• Savoir comment faire jouer les musiques les unes après les autres automatiquement.
• Pour ne pas surcharger le programme principal, aller chercher dans canon.py les chemins de chaque musique.

Merci !

-
Edité par I-Scryper 17 avril 2017 à 20:35:32

Autre chose, je dois mettre self devant une variable seulement si je dois l'utiliser, par exemple, dans une autre fonction ?

Pour la musique je ne sais pas, n'ayant jamais touché à cette partie.

Pour le self, tu dois le mettre quand tu modifies/utilises un attribut ou quand tu utilises une méthode. Ça signifie que tu utilises un élément interne à ton objet.

Je vais continuer à chercher pour ça de mon coté. 

En attendant, je vais rajouter des options. Pour le moment je travaille sur la possibilité de changer la couleur du corps et de la buse du canon. J'ai donc modifié la méthode __init__() pour rajouter mon canon en paramètre, comme je l'ai fait pour la classe Bureau. Et j'ai créé 3 nouvelles fonctions :

def __init__(self, matrice, x, y, canon) :
    self.x = x  # Coordonée x du bouton
    self.y = y  # Coordonée y du bouton
    self.fen = matrice   # Dans quelle fenêtre on place le bouton
    self.canon = canon
    self.Opts = Button(self.fen, text = 'Options', command = self.options).place(x = self.x, y = self.y)   # Création et placement du bouton
    self.sons = ['C:\\Users\\Mazzeo Roberto\\Desktop\\Florian\\Ressources PB\\Chant Militaire.ogg', 'C:\\Users\\Mazzeo Roberto\\Desktop\\Florian\\Ressources PB\\Black Beatles.ogg',
    'C:\\Users\\Mazzeo Roberto\\Desktop\\Florian\\Ressources PB\\Marshall Mathers.ogg', 'C:\\Users\\Mazzeo Roberto\\Desktop\\Florian\\Ressources PB\\Human.ogg',
    'C:\\Users\\Mazzeo Roberto\\Desktop\\Florian\\Ressources PB\\Rolex.ogg', "C:\\Users\\Mazzeo Roberto\\Desktop\\Florian\\Ressources PB\\Stressed Out.ogg",
    'C:\\Users\\Mazzeo Roberto\\Desktop\\Florian\\Ressources PB\\Shape Of You.ogg', 'C:\\Users\\Mazzeo Roberto\\Desktop\\Florian\\Ressources PB\\Go Gyal.ogg',
    'C:\\Users\\Mazzeo Roberto\\Desktop\\Florian\\Ressources PB\\Tiimmy Turner.ogg', 'C:\\Users\\Mazzeo Roberto\\Desktop\\Florian\\Ressources PB\\The melody.ogg']

def validerCC(self, evtCC) :
    """Modifie la couleur du corps du canon."""
    self.entryCC.delete(0, END)

def validerCB(self, evtCB) :
    """Modifie la couleur de la buse du canon."""
    self.entryCB.delete(0, END)

def changerCouleurs(self) :
    """Cette fonction permet de changer la couleur du corps et de la buse du canon."""
    self.f4.destroy()
    self.f5 = Tk()
    self.f5.title("Couleurs du canon")
    self.f5.geometry('490x120')
    couleurCorps = Label(self.f5, text = 'Entrez la nouvelle couleur du corps du canon :', font = ('Arial', 12)).place(x = 2, y = 30)
    couleurBuse = Label(self.f5, text = 'Entrez la nouvelle couleur de la buse du canon :', font = ('Arial', 12)).place(x = 2, y = 67)
    aide = Label(self.f5, text = 'Appuyez sur la touche ENTER pour valider. Le nom de la couleur doit être écrit en ANGLAIS.').place(x = 2, y = 2)
    listDesCouleurs = Button(self.f5, text = 'Voir les couleurs disponibles', command = self.afficherCouleurs).pack(side = BOTTOM)
    self.entryCC = Entry(self.f5, width = 20)   # Entry pour la couleur du corps du canon
    self.entryCC.place(x = 330, y = 34)
    self.entryCB = Entry(self.f5, width = 20)   # Entry pour la couleur de la buse du canon
    self.entryCB.place(x = 342, y = 71)
    self.entryCC.bind('<Return>', self.validerCC)
    self.entryCB.bind('<Return>', self.validerCB)
    self.f5.mainloop()

Donc dans canon, je vais mettre les éléments qui composent le canon sous forme de variables. Mais comment j'y accède via une autre classe ?

Merci !

-
Edité par I-Scryper 21 avril 2017 à 21:53:54

Si ton canon dispose d'attributs (les variables dont tu as mis self devant) et bien tu peux modifier ces attributs directement avec ton objet canon:

canon.couleur_corps = "blue"
canon.couleur_buse = "green"

En admettant que ton objet a deux attributs qui sont couleur_corps et couleur_buse

J'ai eu une autre idée entre temps et j'ai codé ça en plus dans ma classe Canon() :

def modifierCouleur(self, eltAModifier, nvlCouleurCorps = "", nvlCouleurBuse = "") :
    """Cette fonction s'occupe de modifier les couleurs de la buse et du corps du canon,
    en fonction de ce qu'a choisi l'utilisateur dans les Options."""
    if eltAModifier == "CC" :
        self.corps.configure(outline = nvlCouleurCorps, fill = nvlCouleurCorps)
    else :
        self.buse.configure(fill = nvlCouleurBuse)

La fonction ne fonctionne pas, j'obtiens une AttributeError : AttributeError: 'int' object has no attribute 'configure'. Et pareil quand je remplace configure par config.

Et dans ma classe Options() :

def validerCC(self, evtCC) :
    """Modifie la couleur du corps du canon."""
    self.couleurC = self.entryCC.get()
    self.canon.modifierCouleur("CC", self.couleurC)
    self.entryCC.delete(0, END)

def validerCB(self, evtCB) :
    """Modifie la couleur de la buse du canon."""
    self.couleurB = self.entryCB.get()
    self.canon.modifierCouleur("CB", self.couleurB)
    self.entryCB.delete(0, END)

def changerCouleurs(self) :
    """Cette fonction permet de changer la couleur du corps et de la buse du canon."""
    self.f4.destroy()
    self.f5 = Tk()
    self.f5.title("Couleurs du canon")
    self.f5.geometry('490x120')
    couleurCorps = Label(self.f5, text = 'Entrez la nouvelle couleur du corps du canon :', font = ('Arial', 12)).place(x = 2, y = 30)
    couleurBuse = Label(self.f5, text = 'Entrez la nouvelle couleur de la buse du canon :', font = ('Arial', 12)).place(x = 2, y = 67)
    aide = Label(self.f5, text = 'Appuyez sur la touche ENTER pour valider. Le nom de la couleur doit être écrit en ANGLAIS.').place(x = 2, y = 2)
    listDesCouleurs = Button(self.f5, text = 'Voir les couleurs disponibles', command = self.afficherCouleurs).pack(side = BOTTOM)
    self.entryCC = Entry(self.f5, width = 20)   # Entry pour la couleur du corps du canon
    self.entryCC.place(x = 330, y = 34)
    self.entryCB = Entry(self.f5, width = 20)   # Entry pour la couleur de la buse du canon
    self.entryCB.place(x = 342, y = 71)
    self.entryCC.bind('<Return>', self.validerCC)
    self.entryCB.bind('<Return>', self.validerCB)
    self.f5.mainloop()

Du coup j'aimerais juste savoir comment ne plus obtenir mon AttributeError pour que ça fonctionne.

Merci !

-
Edité par I-Scryper 22 avril 2017 à 11:44:19

Svp.

Merci !

Qu'est-ce qu'un int en python?

Un entier ?

Exact. L'erreur te dit que le type int n'a pas de méthode configure. Donc trois possibilités:

• Soit tu t'es trompé dans le nom de ta méthode
• Soit tu n'utilises pas la méthode sur le bon objet
• Soit ta variable n'a pas le bon type

Ici tu utilises configure sur les variables corps et buse, qui sont apparemment des entiers. À toi de voir si c'est normal qu'elles aient ce type là (en lisant la doc qui les a générées). Si c'est le cas, alors ça signifie que le problème vient d'une des deux autres hypothèses.

En effet,  je me suis trompé de méthode. Je devais utiliser la méthode itemconfig comme suit :

    def modifierCouleur(self, eltAModifier, nvleCouleur = "") :
        """Cette fonction s'occupe de modifier les couleurs de la buse et du corps du canon,
        en fonction de ce qu'a choisi l'utilisateur dans les Options."""
        if eltAModifier == "CC" :
            self.Canv.itemconfig(self.corps, outline = nvleCouleur, fill = nvleCouleur)
        elif eltAModifier == "CB" :
            self.Canv.itemconfig(self.buse, fill = nvleCouleur)
        else :
            self.Canv.configure(bg = nvleCouleur)

Merci !

-
Edité par I-Scryper 2 mai 2017 à 19:25:12

Bonjour,

Juste une petite question, est-ce que je peut réutiliser la méthode __init__() d'une de mes classes pour créer un autre objet de cette classe ?

Et est-ce qu'il est possible de détruire un canon rien qu'en connaissant son nom ? Par exemple en faisant une recherche dans une liste de canons ? 

Le code a beaucoup évolué, voici la parties concernée :

class Parametres() :
    """Classe donnant accès aux paramètres du jeu."""
    def __init__(self, fen, x, y, Canv, can, bur) :
        self.fen = fen
        self.x = x
        self.y = y
        self.Canv = Canv
        self.can = can
        self.bur = bur
        par = Button(self.fen, text = 'Paramètres', command = self.params).place(x = self.x, y = self.y)
        self.sons = ['C:\\Users\\xxxxx\\Desktop\\Florian\\Ressources PB\\Chant Militaire.ogg', 'C:\\Users\\xxxxx\\Desktop\\Florian\\Ressources PB\\Black Beatles.ogg',
        'C:\\Users\\xxxxx\\Desktop\\Florian\\Ressources PB\\Marshall Mathers.ogg', 'C:\\Users\\xxxxx\\Desktop\\Florian\\Ressources PB\\Human.ogg',
        'C:\\Users\\xxxxx\\Desktop\\Florian\\Ressources PB\\Rolex.ogg', "C:\\Users\\xxxxx\\Desktop\\Florian\\Ressources PB\\Stressed Out.ogg",
        'C:\\Users\\xxxxx\\Desktop\\Florian\\Ressources PB\\Shape Of You.ogg', 'C:\\Users\\xxxxx\\Desktop\\Florian\\Ressources PB\\Go Gyal.ogg',
        'C:\\Users\\xxxxx\\Desktop\\Florian\\Ressources PB\\Tiimmy Turner.ogg', 'C:\\Users\\xxxxx\\Desktop\\Florian\\Ressources PB\\The melody.ogg']

    def params(self) :
        """Accès aux paramètres généraux."""
        self.f1 = Tk()
        self.f1.title("Paramètres")
        mus = Button(self.f1, text = 'Changer la musique', width = 30, command = self.optsMusique).pack(pady = 2)
        joueurs = Button(self.f1, text = 'Ajouter/supprimer des joueurs', width = 30, command = self.optsJoueurs).pack(pady = 2)
        fond = Button(self.f1, text = 'Changer la couleur du fond de jeu', width = 30, command = self.couleurFond).pack(pady = 2)
        self.f1.mainloop()

    def optsMusique(self) :
        """Fonction pour changer la musique du jeu."""
        self.f1.destroy()
        self.f2 = Tk()  # création d'une fenêtre pour choisir la musique de fond
        self.f2.title("Changer la musique")                    #
        self.f2.geometry('266x142')                            # ==> options de la fenêtre
        self.f2.resizable(width = False, height = False)       #
        MusiqueDeBase = Button(self.f2, text = 'Chant militaire', width = 17, command = lambda : self.musique(0)).place(x = 2, y = 2)   # 1ère colonne des boutons permettant de choisir la musique
        RaeSremmurd = Button(self.f2, text = 'Black beatles', width = 17, command = lambda : self.musique(1)).place(x = 2, y = 30)
        Eminem = Button(self.f2, text = 'Marshall Mathers', width = 17, command = lambda : self.musique(2)).place(x = 2, y = 58)
        RagNBoneMan = Button(self.f2, text = 'Human', width = 17, command = lambda : self.musique(3)).place(x = 2, y = 86)
        AyoTeo = Button(self.f2, text = 'Rolex', width = 17, command = lambda : self.musique(4)).place(x = 2, y = 114)
        Pilots = Button(self.f2, text = 'Stressed Out', width = 17, command = lambda : self.musique(5)).place(x = 135, y = 2)   # 2ème colonne
        EdSheeran = Button(self.f2, text = 'Shape Of You', width = 17, command = lambda : self.musique(6)).place(x = 135, y = 30)
        Ahzee = Button(self.f2, text = 'Go Gyal', width = 17, command = lambda : self.musique(7)).place(x = 135, y = 58)
        Desiigner = Button(self.f2, text = 'Tiimmy turner', width = 17, command = lambda : self.musique(8)).place(x = 135, y = 86)
        DVegasETLMike = Button(self.f2, text = 'The melody', width = 17, command = lambda : self.musique(9)).place(x = 135, y = 114)
        self.f2.mainloop()

    def musique(self, pos) :
        """Charge et joue la musique choisie."""
        pygame.mixer.music.load(self.sons[pos])   # chargement de la musique
        pygame.mixer.music.play()   # la musique est jouée
        self.f2.destroy()

    def optsJoueurs(self) :
        """Ajouter/supprimer des joueurs"""
        self.f1.destroy()
        self.f5 = Tk()
        self.f5.title("Ajout/suppression de joueurs")
        self.f5.geometry('640x350')
        self.f5.resizable(width = False, height = False)
        canvSeparation = Canvas(self.f5, bg = 'black', width = 1, height = 370).place(x = 331, y = -5)  # Canvas très fin pour séparer les parties d'ajout et de suppression
        var = IntVar()
        # Objets réservés à l'ajout
        labelAjout = Label(self.f5, text = "Ajout de joueur", font = ('Arial', 12, 'bold underline')).place(x = 100, y = 5)
        # Objets pour le choix de la position
        self.lPosition = Label(self.f5, text = 'Position initiale\n du nouveau canon :', font = ('Arial', 10, 'bold'))
        self.lPosition.place(x = 2, y = 70)
        rbPosition = Radiobutton(self.f5, text = 'Aléatoire', variable = var, value = 1, command = self.posAleatoire).place(x = 160, y = 65)
        rbPosition2 = Radiobutton(self.f5, text = 'Choisir', variable = var, value = 2, command = self.reactiver).place(x = 160, y = 90)
        self.ePosX = Entry(self.f5, width = 5, state = NORMAL)
        self.ePosX.place(x = 290, y = 67)
        self.ePosY = Entry(self.f5, width = 5, state = NORMAL)
        self.ePosY.place(x = 290, y = 92)
        lPosX = Label(self.f5, text = "X :").place(x = 270, y = 65)
        lPosY = Label(self.f5, text = "Y :").place(x = 270, y = 90)
        # Objets pour le choix du nom
        self.lNom = Label(self.f5, text = 'Nom du nouveau canon :', font = ('Arial', 10, 'bold'))
        self.lNom.place(x = 2, y = 140)
        # Objets pour le choix de la couleur du corps
        self.lCoulCorps = Label(self.f5, text = 'Couleur du corps\n du nouveau canon :', font = ('Arial', 10, 'bold'))
        self.lCoulCorps.place(x = 2, y = 190)
        # Objets pour le choix de la couleur de la buse
        self.lCoulBuse = Label(self.f5, text = 'Couleur de la buse\n du nouveau canon :', font = ('Arial', 10, 'bold'))
        self.lCoulBuse.place(x = 2, y = 250)
        # Bouton de validation
        val = Button(self.f5, text = 'Valider', width = 30, height = 10, command = self.validerNvoJoueur).pack(side = BOTTOM)
        # Objets réservés à la suppression
        labelSupp = Label(self.f5, text = "Suppression de joueur", font = ('Arial', 12, 'bold underline')).place(x = 405, y = 5)
        lCanSupp = Label(self.f5, text = 'Quel canon doit être suprimé ?', font = ('Arial', 10, 'bold')).place(x = 337, y = 70)
        self.f5.mainloop()

    def posAleatoire(self) :
        """Cette méthode choisit une position aléatoire et désactive les Entry
        pour le choix manuel de la position du nouveau canon."""
        self.ePosX.configure(state = DISABLED)
        self.ePosY.configure(state = DISABLED)
        self.posX = randint(10, 490)
        self.posY = randint(10, 490)

    def reactiver(self) :
        """Réactive les Entry du choix manuel de la position si l'utilisateur
        les avait désactivé mais décide de choisir lui même la position de son canon."""
        self.ePosX.configure(state = NORMAL)
        self.ePosY.configure(state = NORMAL)

    def validerNvoJoueur(self) :
        """Vérifie si tout les champs sont remplis, dans ce cas les choix sont validés et le canon créé.
        Dans le cas où tout les champs ne sont pas remplis ou si un paramètre est éronné."""
        print("test ok")

    def couleurFond(self) :
        """Changer la couleur du fond de jeu."""
        self.f1.destroy()
        self.f3 = Tk()
        self.f3.title('Changer la couleur du fond de jeu')
        self.f3.geometry('490x90')
        self.f3.resizable(width = False, height = False)
        aide = Label(self.f3, text = 'Appuyez sur la touche ENTER pour valider. Le nom de la couleur doit être écrit en ANGLAIS.').place(x = 2, y = 2)
        self.entryCCanvas = Entry(self.f3, width = 20)   # Entry pour la couleur du Canvas
        self.entryCCanvas.place(x = 300, y = 34)
        self.entryCCanvas.bind('<Return>', self.validerCCanvas)
        coulCanvas = Label(self.f3, text = 'Entrez la nouvelle couleur du fond de jeu : ', font = ('Arial', 12)).place(x = 2, y = 30)
        listeDesCouleurs = Button(self.f3, text = 'Voir les couleurs disponibles', command = self.afficherCouleurs).pack(side = BOTTOM)
        self.f3.mainloop()

    def validerCCanvas(self, evtCCanvas) :
        """Modifie la couleur du canvas."""
        couleurCanvas = self.entryCCanvas.get()
        self.Canv.configure(bg = couleurCanvas)
        self.entryCCanvas.delete(0, END)

    def afficherCouleurs(self) :
        """Affiche les couleurs disponibles pour le corps et la buse du canon."""
        f4 = Tk()
        f4.geometry('50x100')
        f4.resizable(width = False, height = False)
        fichier = open('C:\\Users\\xxxxx\\Desktop\\Florian\\Ressources PB\\Couleurs.txt','r')
        sb = Scrollbar(f4)
        sb.pack(side = RIGHT, fill = Y)
        lb = Listbox(f4, yscrollcommand = sb.set)
        for mot in fichier :
            lb.insert(END, " " + str(mot))
        fichier.close()
        lb.pack(side = LEFT, fill = BOTH)
        sb.config(command = lb.yview)
        f4.mainloop()

Merci !

-
Edité par I-Scryper 5 mai 2017 à 17:41:18