IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Tkinter Python Discussion :

Probleme animation idle 2.7


Sujet :

Tkinter Python

  1. #1
    Membre averti
    Homme Profil pro
    Caen
    Inscrit en
    Novembre 2012
    Messages
    20
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Caen
    Secteur : Administration - Collectivité locale

    Informations forums :
    Inscription : Novembre 2012
    Messages : 20
    Par défaut Probleme animation idle 2.7
    bonsoir, je continu mon apprentissage sur le language, et un nouveau probleme arrive, et biensur, je ne voies pas du tout comment en venir a bout.
    la fenetre est en place, l'animation des canons fonctionne, mais je peux pas leur faire lancer d'obus?
    merci pour vos reponses.

    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
    from Tkinter import *
    from math import sin, cos, pi
    from random import randrange
     
    class Canon:
            """ Petit canon graphique """
            def __init__(self, boss, id, x, y, sens, coul):
                    self.boss = boss                                #ref.du canevas
                    self.appli = boss.master                        #ref. de la fenêtre d'application
                    self.id = id                                    #identifiant du canon (chaîne)
                    self.coul = coul                                #couleur associée au canon
                    self.x1, self.y1 = x, y                         #axe de rotation du canon
                    self.sens = sens                                #sens de tir(-1:gauche, +1:droite)
                    self.lbu = 30                                   #longueur de la buse
                    self.angle = 0                                  #hausse par défaut (angle de tir)
                    # retrouver la largeur et la hauteur du canevas:
                    self.xMax = int(boss.cget('width'))
                    self.yMax = int(boss.cget('height'))
                    # dessiner la buse du canon (horizontale) :
                    self.x2, self.y2 = x + self.lbu * sens, y
                    self.buse = boss.create_line(self.x1, self.y1,self.x2, self.y2, width =10)
                    # dessiner le corps du canon (cercle de couleur) :
                    self.rc = 15                                    #rayon du cercle
                    self.corps = boss.create_oval(x -self.rc, y -self.rc, x +self.rc, 
                                                     y +self.rc, fill =coul)
                    # pré-dessiner un obus caché (point en dehors du canevas) :
                    self.obus = boss.create_oval(-10, -10, -10, -10, fill='red')
                    self.anim = False                               #indicateurs d'animation
                    self.expo = False                               # et d'explosion
     
            def orienter(self, angle):
                    "régler la hausse du canon"
                    # rem: le paramètre <angle> est reçu en tant que chaîne.
                    # il faut donc le traduire en réel, puis le convertir en radians :
                    self.angle = float(angle)*pi/180
                    # rem: utiliser la méthode coords de préférence avec des entiers :
                    self.x2 = int(self.x1 + self.lbu * cos(self.angle) * self.sens)
                    self.y2 = int(self.y1 - self.lbu * sin(self.angle))
                    self.boss.coords(self.buse, self.x1, self.y1, self.x2, self.y2)
     
            def deplacer(self, x, y):
                    "amener le canon dans une nouvelle position x, y"
                    dx, dy = x -self.x1, y -self.y1                 #valeur du déplacement
                    self.boss.move(self.buse, dx, dy)
                    self.boss.move(self.corps, dx, dy)
                    self.x1 += dx
                    self.y1 += dy
                    self.x2 += dx
                    self.y2 += dy
     
            def feu(self):
                    "tir d'un obus - seulement si le précédent à fini son vol"
                    if not (self.anim or self.explo):
                            self.anim = True
                            self.explo = True
                            #récupérer la description de tous les canons présents :
                            self.guns = self.appli.dictionnaireCanons()
                            #position de départ de l'obus (c'est la bouche du canon) :
                            self.boss.coords(self.obus, self.x2 -3, self.y2 -3,self.x2 +3, self.y2 +3)
                            v = 17                                  #vitesse initiale
                            #composantes verticale et horizontale de cette vitesse:
                            self.vy = -v *sin(self.angle)
                            self.vx = v *cos(self.angle) *self.sens
                            self.animer_obus()
                            return True                             # =>signaler que le coup est parti
                    else:
                            return False                            # => le coup n'a pas pu être tiré
     
            def animer_obus(self):
                    "animer l'obus (trajectoire balistique)"
                    if self.anim:
                            self.boss.move(self.obus, int(self.vx), int(self.vy))
                            c = self.boss.coords(self.obus)         #coord. résultantes
                            xo, yo = c[0] +3, c[1] +3               #coord. du centre de l'obus
                            self.test_obstacle(xo, yo)              #a-t-on atteint un obstacle?
                            self.vy += .4                           #accélération verticale
                            self.boss.after(20, self.animer_obus)
                    else:
                            #animation terminée - cacher l'obus et déplacer les canons :
                            self.fin_animation()
     
            def test_obstacle(self, xo, yo):
                    "évaluer si l'obus a atteint une cible ou les limites du jeu"
                    if yo >self.yMax or xo <0 or xo >self.xMax:
                            self.anim =False
                            return
                    #analyser le dictionnaire des canons pour voir si les coordonnées
                    #de l'un d'entre eux sont proches de celle de l'obus:
                    for id in self.guns:                            #id = clef dans dictionnaire
                            gun = self.guns[id]                     #valeur correspondante
                            if xo < gun.x1 +self.rc and xo > gun.x1 -self.rc \
                            and yo < gun.y1 +self.rc and y0 > gun.y1 -self.rc:
                                    self.anim =False
                                    #dessiner l'explosion de l'obus (cercle jaune):
                                    self.explo = self.boss.create_oval(xo -12, yo -12,
                                            xo +12, yo +12, fill='yellow', width =0)
                                    self.hit =id                    #référence de la cible touchée
                                    self.boss.after(150, self.fin_explosion)
                                    break
     
            def fin_explosion(self):
                    "effacer l'explosion, ré-initialiser l'obus, gérer le score"
                    self.boss.delete(self.explo)                    #effacer l'explosion
                    self.explo =False                               #autoriser un nouveau tir
                    #signaliser le succès à la fenêtre maîtresse:
                    self.appli.goal(self.id, self.hit)
     
            def fin_animation(self):
                    "action à accomplir lorsque l'obus a terminé sa trajectoire"
                    self.appli.disperser()                          #déplacer les canons
                    # cacher l'obus (en l'expédiant hors du canevas):
                    self.boss.coords(self.obus, -10, -10, -10, -10)
     
    class Pupitre (Frame):
            """Pupitre de pointage associé à un canon"""
            def __init__(self, boss, canon):
                    Frame.__init__(self, bd =3, relief =GROOVE)
                    self.score =0
                    self.appli =boss                                        #ref. de l'application
                    self.canon = canon                                      #ref.du canon associé
                    #Système de réglage de l'angle de tir:
                    self.regl =Scale(self, from_=75, to =-15, troughcolor=canon.coul,
                                    command =self.orienter)
                    self.regl.set(45)                                       #angle initial de tir
                    self.regl.pack(side =LEFT)
                    # Etiquette d'iddentification du canon :
                    Label(self, text =canon.id).pack(side =TOP, anchor =W, pady =5)
                    # Bouton de tir:
                    self.btir =Button(self, text ='Feu !', command =self.tirer)
                    self.btir.pack(side =BOTTOM, padx =5, pady =5)
                    Label(self, text ="points").pack()
                    self.points =Label(self, text=' 0 ',bg ='white')
                    self.points.pack()
                    #positionner à gauche ou à droite suivant le sens du canon :
                    if canon.sens == -1:
                            self.pack(padx =5, side =RIGHT)
                    else:
                            self.pack(padx =5, pady =5, side =LEFT)
     
            def tirer(self):
                    "déclencher le tir du canon associé"
                    self.canon.feu()
     
            def orienter(self, angle):
                    "ajuster la hausse du canon associé"
                    self.canon.orienter(angle)
     
            def attribuerPoint(self, p):
                    "incrémenter ou décrémenter le score, de <p> points"
                    self.score += p
                    self.points.config(text = ' %s ' % self.score)
     
    class Application(Frame):
            '''Fenêtre principale de l'application'''
            def __init__(self):
                    Frame.__init__(self)
                    self.master.title('>>>>> Boum ! Boum ! <<<<<')
                    self.pack()
                    self.jeu = Canvas(self, width =400, height =250, bg ='ivory',
                            bd =3, relief =SUNKEN)
                    self.jeu.pack(padx =8, pady =8, side =TOP)
                    self.guns ={}                                   #dictionnaire des canons présents
                    self.pupi ={}                                   #dictionnaire des pupitres présents
                    #instanciation de 2 'objets canon (+1, -1 = sens oposés) :
                    self.guns["Dramdun"] = Canon(self.jeu, "Dramdun", 30, 200, 1, "red")
                    self.guns["linux"] = Canon(self.jeu, "linux", 370, 200, -1, "blue")
                    #instanciation de 2 pupitres de pointage associés à ces canons :
                    self.pupi["Dramdun"] = Pupitre(self, self.guns["Dramdun"])
                    self.pupi["linux"] = Pupitre(self, self.guns["linux"])
     
            def disperser(self):
                    "déplacer aléatoirementles canons"
                    for id in self.guns:
                            gun = self.guns[id]
                            #positionner à gauche ou à droite, suivant sens du canon :
                            if gun.sens == -1:
                                    x = randrange(320, 380)
                            else:
                                    x = randrange(20, 80)
                            #déplacement proprement dit:
                            gun.deplacer(x, randrange(150, 240))
     
            def goal(self, i, j):
                    "le canon <i> signale qu'il a atteint l'adversaire <j>"
                    if i != j:
                            self.pupi[i].attribuerPoint(1)
                    else:
                            self.pupi[i].attribuerPoint(-1)
     
            def dictionnaireCanons(self):
                    "renvoyer le dictionnaire décrivant les canons présents"
                    return self.guns
     
    if __name__ == '__main__':
            Application().mainloop()

  2. #2
    Membre Expert
    Profil pro
    Développeur en systèmes embarqués retraité
    Inscrit en
    Mars 2006
    Messages
    952
    Détails du profil
    Informations personnelles :
    Localisation : France, Bas Rhin (Alsace)

    Informations professionnelles :
    Activité : Développeur en systèmes embarqués retraité
    Secteur : Industrie

    Informations forums :
    Inscription : Mars 2006
    Messages : 952
    Par défaut
    Salut,

    Le message d'erreur est pourtant clair:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    Exception in Tkinter callback
    Traceback (most recent call last):
      File "c:\python27\lib\lib-tk\Tkinter.py", line 1410, in __call__
        return self.func(*args)
      File "dummy.py", line 142, in tirer
        self.canon.feu()
      File "dummy.py", line 53, in feu
        if not (self.anim or self.explo):
    AttributeError: Canon instance has no attribute 'explo'
    Tu déclares une variable 'expo' et tu appelles 'explo'... Il faut au moins que tu aies de quoi lire les erreurs, même si tu veux programmer en graphique.
    Sinon, un autre problème: Tu commentes abondement en français sans déclarer d'encodage. Du coup, chez moi par exemple, l'interpréteur me pète une erreur à chacun de ces caractères.

    A+

    Pfeuh

  3. #3
    Membre averti
    Homme Profil pro
    Caen
    Inscrit en
    Novembre 2012
    Messages
    20
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Caen
    Secteur : Administration - Collectivité locale

    Informations forums :
    Inscription : Novembre 2012
    Messages : 20
    Par défaut
    grand merci pour la reponse,
    le programme fonctionne apres une nouvelle erreur reperer "line 82".
    et dsl pour tout ces commentaire, ils sont la pour m'aider au mieu dans la comprehension.

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. SDL: probleme animation
    Par jalil119 dans le forum SDL
    Réponses: 3
    Dernier message: 01/05/2010, 00h57
  2. Probleme animation Textblock background
    Par bnogent dans le forum Windows Presentation Foundation
    Réponses: 1
    Dernier message: 16/07/2009, 12h05
  3. probleme animation flash
    Par pireschrist dans le forum Flash
    Réponses: 2
    Dernier message: 12/09/2007, 11h18
  4. [Publication HTML] Probleme animation flash php
    Par Nounoursonne dans le forum Flash
    Réponses: 1
    Dernier message: 27/07/2007, 09h30
  5. probleme animation locale
    Par Alex35 dans le forum Flash
    Réponses: 1
    Dernier message: 22/11/2006, 11h35

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo