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

Programmation multimédia/Jeux Python Discussion :

Probleme d'arret de mouvement sur objet


Sujet :

Programmation multimédia/Jeux Python

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre averti
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    Mai 2013
    Messages
    54
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Canada

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Alimentation

    Informations forums :
    Inscription : Mai 2013
    Messages : 54
    Par défaut Probleme d'arret de mouvement sur objet
    Bonjour à tous,

    Je commence en programmation et j'essaie de créé un petit jeu très simple pour me faire la main.

    Le but étant de lancer des projectiles vers des météorites afin de les détruire avant qu'elle ne touche la terre.

    Bon pour l'instant, j'ai réussi a créé le "pion" du joueur qui se déplace dans la fenêtre de gauche a droite, et j'ai aussi réussi a faire tirer les projectiles à partir de se même pion.

    Mon problème c'est que je ne peu pas tirer plusieurs projectile en même temps. Si je le fais, le projectile précédent s'arrête et en plus j'ai une erreur d'indentation lorsque j'essaie d'effacer le projectile qui atteint le haut de ma fenêtre...

    Je vous met mon code source: (soyer indulgent je commence en programmation et j'avoue ne pas avoir tout saisi de la programmation orienté objet )

    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
     
     
    # -*- coding:Latin-1 -*-
     
    from tkinter import *
    from random import randrange
     
    class Joueur(object):
        """ Crée un joueur """
     
        def __init__(self, can, posX, posY):
     
            self.can = can
            self.posX = posX #Utile pour définir
            self.posY = posY #l'emplacement selon le canvas
     
            # Création d'un rectangle de 20 * 20
            self.joueur = self.can.create_rectangle(self.posX, self.posY,
                                                     self.posX+20, self.posY+20,
                                                     fill = "red")
     
            # Gestion des évènements
            self.can.bind("<Motion>", self.move)
            self.can.bind("<Button-1>", self.tire, add = "+")
     
        def move(self, event):
            " Fais bouger le joueur selon la souri "
     
            # Récupère la position de la souri
            self.mouseX = event.x-10
            self.mouseY = event.y+10
     
            self.can.coords(self.joueur, self.mouseX, self.posY,
                            self.mouseX+20, self.posY+20)
     
     
        def tire(self, event):
            " Crée un projectile "
     
            self.lazer = self.can.create_line(self.mouseX+10, self.posY
                                              , self.mouseX+10, self.posY+30,
                                              fill = "blue")
     
            self.deplacetire()
     
        def deplacetire(self):
            " Déplace le projectile jusqu'en haut du canvas "
     
            # Récupère la position du projectile
            self.posLazer = self.can.coords(self.lazer)
            self.posLazerY = self.posLazer[1]
     
            if self.posLazerY > 0:
                self.can.move(self.lazer, 0, -10)
                self.can.after(30, self.deplacetire)
            else:
                self.can.delete(self.lazer)
     
    class App(object):
        """ Application principal """
     
        def __init__(self, larg = 200, haut = 200):
     
            self.larg = larg
            self.haut = haut
     
            # Fenetre principal
            self.root = Tk()
     
            # Canvas de la fenetre principal
            self.can = Canvas(self.root, width = self.larg,
                              height = self.haut, bg = "black")
            self.can.pack(side = TOP)
     
            # Bouton pour quitter qui s'ajuste à la largeur
            # de la fenêtre d'où le "int(larg/7)"
            Button(self.root, text="Quitter", bg="dark grey",
                   width = int(larg/7), command =
                   self.root.quit).pack(side = BOTTOM)
     
            # Appel la classe qui créera le joueur et le
            # positionne au centre
            Joueur(self.can, self.larg/2, self.haut-20)
     
        def mainloop(self):
            "Methode qui referme la fenetre"
            self.root.mainloop()
            self.root.destroy()
     
    if __name__ == "__main__":
     
        play = App(600, 600)
        play.mainloop()

  2. #2
    Expert éminent
    Homme Profil pro
    Architecte technique retraité
    Inscrit en
    Juin 2008
    Messages
    21 741
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Manche (Basse Normandie)

    Informations professionnelles :
    Activité : Architecte technique retraité
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2008
    Messages : 21 741
    Par défaut
    Salut,
    Lorsque le joueur il tire, l'attribut "lazer" de l'instance de Joueur sera initialisé à un item "line" du le canvas. Comme il n'y a qu'un Joueur, tirer plusieurs fois écrase l'attribut laser: l'ancien item n'avance plus et on a perdu son identifiant.

    Honnêtement je ne vois pas trop pourquoi vous vous êtes acharné à vouloir créer des classes pour App et Joueur: pour l'instant, vous ne fabriquez pas plusieurs instances de ces classes là. Par contre, si vous voulez avoir plusieurs tirs de laser qui volent en même temps...

    Dommage! c'est peut être le seul objet qui mérite d'avoir une "class" pour pouvoir en fabriquer plusieurs durant la vie de l'application (ou de la partie).

    - W
    Architectures post-modernes.
    Python sur DVP c'est aussi des FAQs, des cours et tutoriels

  3. #3
    Membre averti
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    Mai 2013
    Messages
    54
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Canada

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Alimentation

    Informations forums :
    Inscription : Mai 2013
    Messages : 54
    Par défaut
    Hahaha, j'ai eu le flash en prennent ma douche

    J'avais pas compris qu'il fallais créé un objet pour le projectile... Comme je vous disais je commence et j'ai pas tout compris encore

    Voici le nouveau code qui marche pour ceux que sa l'intéresse:

    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
     
    # -*- coding:Latin-1 -*-
     
    from tkinter import *
    from random import randrange
     
    class Tire(object):
        """ Crée un projectile """
        def __init__(self, can, posJoueur):
     
            self.can = can
            # Récupère la position du joueur en X et Y
            self.posJoueur = posJoueur
            self.posXJ = self.posJoueur[0]
            self.posYJ = self.posJoueur[1]
     
            self.lazer = self.can.create_line(self.posXJ+10, self.posYJ
                                              , self.posXJ+10, self.posYJ+30,
                                              fill = "blue")
     
            self.deplaceTire()
     
        def deplaceTire(self):
            " Déplace le projectile jusqu'en haut du canvas "
     
            # Récupère la position du projectile
            self.posLazer = self.can.coords(self.lazer)
            self.posLazerY = self.posLazer[1]
     
            if self.posLazerY > 0:
                self.can.move(self.lazer, 0, -10)
                self.can.after(30, self.deplaceTire)
            else:
                self.can.delete(self.lazer)
     
    class Joueur(object):
        """ Crée un joueur """
     
        def __init__(self, can, posX, posY):
     
            self.can = can
            self.posX = posX #Utile pour définir
            self.posY = posY #l'emplacement selon le canvas
     
            # Création d'un rectangle de 20 * 20
            self.joueur = self.can.create_rectangle(self.posX, self.posY,
                                                     self.posX+20, self.posY+20,
                                                     fill = "red")
     
            # Gestion des évènements
            self.can.bind("<Motion>", self.move)
            self.can.bind("<Button-1>", self.tire, add = "+")
     
        def move(self, event):
            " Fais bouger le joueur selon la souri "
     
            # Récupère la position de la souri
            self.mouseX = event.x-10
            self.mouseY = event.y+10
     
            self.can.coords(self.joueur, self.mouseX, self.posY,
                            self.mouseX+20, self.posY+20)
     
     
        def tire(self, event):
            " Crée un projectile "
     
            # Récupere la position du joueur
            self.posJoueur = self.can.coords(self.joueur)
     
            Tire(self.can, self.posJoueur)
     
    class App(object):
        """ Application principal """
     
        def __init__(self, larg = 200, haut = 200):
     
            self.larg = larg
            self.haut = haut
     
            # Fenetre principal
            self.root = Tk()
     
            # Canvas de la fenetre principal
            self.can = Canvas(self.root, width = self.larg,
                              height = self.haut, bg = "black")
            self.can.pack(side = TOP)
     
            # Bouton pour quitter qui s'ajuste à la largeur
            # de la fenêtre d'où le "int(larg/7)"
            Button(self.root, text="Quitter", bg="dark grey",
                   width = int(larg/7), command =
                   self.root.quit).pack(side = BOTTOM)
     
            # Appel la classe qui créera le joueur et le
            # positionne au centre
            Joueur(self.can, self.larg/2, self.haut-20)
     
        def mainloop(self):
            "Methode qui referme la fenetre"
            self.root.mainloop()
            self.root.destroy()
     
    if __name__ == "__main__":
     
        play = App(600, 600)
        play.mainloop()

  4. #4
    Membre averti
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    Mai 2013
    Messages
    54
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Canada

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Alimentation

    Informations forums :
    Inscription : Mai 2013
    Messages : 54
    Par défaut
    Citation Envoyé par wiztricks Voir le message

    Honnêtement je ne vois pas trop pourquoi vous vous êtes acharné à vouloir créer des classes pour App et Joueur: pour l'instant, vous ne fabriquez pas plusieurs instances de ces classes là.

    - W
    Et bien en faite je ne sais pas trop pourquoi moi non plus, j'ai suivi plusieurs tuto ici et la et pas mal tout le monde fessais sa comme sa...

    Je me suis donc pas trop posé de question

    J'avoue que je pourrais éliminer la class App... mais pour la class joueur je vois pas trop comment l'enlever, je dois créé un objet Joueur pour pouvoir faire bouger mon pion non?

  5. #5
    Expert éminent
    Homme Profil pro
    Architecte technique retraité
    Inscrit en
    Juin 2008
    Messages
    21 741
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Manche (Basse Normandie)

    Informations professionnelles :
    Activité : Architecte technique retraité
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2008
    Messages : 21 741
    Par défaut
    Citation Envoyé par PascalStl Voir le message
    J'avoue que je pourrais éliminer la class App... mais pour la class joueur je vois pas trop comment l'enlever, je dois créé un objet Joueur pour pouvoir faire bouger mon pion non?
    Hmmm.
    Pour bouger l'item qui représente le Joueur sur le canvas, on peut mémoriser l'iid de l'objet (ce que vous faites dans self.joueur) ou demander à Tk de lui coller votre identifiant via un tag 'joueur' par exemple. Après, pour tirer il faut récupérer la position du joueur. On peut le faire via canvas.bbox('joueur') ou éviter l'appel à Tk en gérant des cx, cy globaux ou associés à une instance de Joueur.

    Pour le fun, j'ai ré-écrit votre code en supprimant Application, en gardant Joueur et en construisant d'autres objets pour les tirs. L'idée étant de séparer le timer du "tir".

    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
    # -*- coding:utf-8 -*-
     
    import tkinter as tk
    from random import randrange
     
    class Joueur:
        dx = 10
        def __init__(self, canvas, x0, y0):
            x1, y1 = x0 + 20, y0 + 20
            self.iid = canvas.create_rectangle(x0, y0, x1, y1, fill = "red")
            self.cx = (x0 + x1) // 2
            self.cy = (y0 + y1) // 2
            self.canvas = canvas
     
     
        def move(self, x):
            " Fais bouger le joueur selon la souri "
            dx = x - self.cx
            self.canvas.move(self.iid, dx, 0)
            self.cx = x
     
     
     
    callbacks = []
    def eventloop(app, delta=50):
     
        def do_callbacks():
            cb_copy = callbacks[:]
            [ cb() for cb in cb_copy ]
            app.after(delta, do_callbacks)
     
        app.after(delta, do_callbacks)
     
     
     
    def tirer(canvas, joueur):
        global callbacks # note
     
        cx = joueur.cx
        y0 = joueur.cy - 5
        y1 = joueur.cy - 30
        dy = 10
        iid = canvas.create_line(cx, y0, cx, y1, fill = "blue")
     
        def move():
            nonlocal y0
            if y0 > 0:
                canvas.move(iid, 0, -dy)
                y0 -= dy
            else:
                canvas.delete(iid)
                callbacks.remove(move)
     
        callbacks.append(move)
     
     
    if __name__ == "__main__":
     
        app = tk.Tk()
     
        width = height = 600
        canvas = tk.Canvas(app, width=width, height=height)
        canvas.pack(side='top')
     
        tk.Button(app, text='Quit', bg="dark grey", command=app.quit
                  ).pack(fill='x', side='bottom')
     
        joueur = Joueur(canvas, width // 2, height - 20)
     
        canvas.bind('<Motion>', lambda e: joueur.move(e.x))
        canvas.bind('<1>', lambda e: tirer(e.widget, joueur))
     
        eventloop(app)
     
        tk.mainloop()
    - W
    Architectures post-modernes.
    Python sur DVP c'est aussi des FAQs, des cours et tutoriels

  6. #6
    Membre averti
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    Mai 2013
    Messages
    54
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Canada

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Alimentation

    Informations forums :
    Inscription : Mai 2013
    Messages : 54
    Par défaut
    Citation Envoyé par wiztricks Voir le message
    Hmmm.

    Pour le fun, j'ai ré-écrit votre code en supprimant Application, en gardant Joueur et en construisant d'autres objets pour les tirs. L'idée étant de séparer le timer du "tir".

    - W
    Beaucoup plus cour comme code , mais il doit m'en rester beaucoup à apprendre car j'y comprend rien hahaha

    N’empêche que la j'ai un autre problême, c'est peu être du à m'a logique de programmation...

    J'ai créé des Météorites qui tombes du ciel, mais comment faire pour dire à l'ordinateur qu'il doit les détruire lorsqu'ils rencontre un de mes tirs???

    Voici où j'en suis rendu: (peu être je devrais revoir tout mon code et m'orienter plus dans la direction du tien)

    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
     
    # -*- coding:Latin-1 -*-
     
    from tkinter import *
    from random import randrange
     
    class Meteor(object):
        """ Crée un météorite """
        def __init__(self, can):
     
            self.can = can
     
            # Récupère la taille du canvas
            self.tailleCanX = int(self.can.cget("width"))
            self.tailleCanY = int(self.can.cget("height"))
     
            # Génère une position X aléatoire
            self.posMX = randrange(5, self.tailleCanX-5)
     
            self.meteor = self.can.create_rectangle(self.posMX,
                                                    0,self.posMX+20, 20, fill = "white")
     
            self.deplaceMeteor()
            # Génére un nouveau météor
            self.can.after(1000, self.repete)
     
        def repete(self):
            """ Réappelle un Meteor """
            Meteor(self.can)
     
        def deplaceMeteor(self):
            """ Déplace le météor vers le bas du canvas """
     
            # Récupère la position du météor
            self.posM = self.can.coords(self.meteor)
            self.posMY = self.posM[1]
     
            # détruit le météor s'il sort du canvas
            if self.posMY < self.tailleCanY:
                self.can.move(self.meteor, 0, +
                              10)
                self.can.after(30, self.deplaceMeteor)
            else:
                self.can.delete(self.meteor)
     
    class Tire(object):
        """ Crée un projectile """
        def __init__(self, can, posJoueur):
     
            self.can = can
            # Récupère la position du joueur en X et Y
            self.posJoueur = posJoueur
            self.posXJ = self.posJoueur[0]
            self.posYJ = self.posJoueur[1]
     
            self.lazer = self.can.create_line(self.posXJ+10, self.posYJ
                                              , self.posXJ+10, self.posYJ+30,
                                              fill = "blue")
     
            self.deplaceTire()
     
        def deplaceTire(self):
            " Déplace le projectile jusqu'en haut du canvas "
     
            # Récupère la position du projectile
            self.posLazer = self.can.coords(self.lazer)
            self.posLazerY = self.posLazer[1]
     
            # Détruit le lazer s'il sort du canvas
            if self.posLazerY > 0:
                self.can.move(self.lazer, 0, -10)
                self.can.after(30, self.deplaceTire)
            else:
                self.can.delete(self.lazer)
     
    class Joueur(object):
        """ Crée un joueur """
     
        def __init__(self, can, posX, posY):
     
            self.can = can
            self.posX = posX #Utile pour définir
            self.posY = posY #l'emplacement selon le canvas
     
            # Création d'un rectangle de 20 * 20
            self.joueur = self.can.create_rectangle(self.posX, self.posY,
                                                     self.posX+20, self.posY+20,
                                                     fill = "red")
     
            # Gestion des évènements
            self.can.bind("<Motion>", self.move)
            self.can.bind("<Button-1>", self.tire, add = "+")
     
        def move(self, event):
            " Fais bouger le joueur selon la souri "
     
            # Récupère la position de la souri
            self.mouseX = event.x-10
            self.mouseY = event.y+10
     
            self.can.coords(self.joueur, self.mouseX, self.posY,
                            self.mouseX+20, self.posY+20)
     
     
        def tire(self, event):
            " Crée un projectile "
     
            # Récupere la position du joueur
            self.posJoueur = self.can.coords(self.joueur)
     
            # Appel d'un projectile
            Tire(self.can, self.posJoueur)
     
    class App(object):
        """ Application principal """
     
        def __init__(self, larg = 200, haut = 200):
     
            self.larg = larg
            self.haut = haut
     
            # Fenetre principal
            self.root = Tk()
     
            # Canvas de la fenetre principal
            self.can = Canvas(self.root, width = self.larg,
                              height = self.haut, bg = "black")
            self.can.pack(side = TOP)
     
            # Bouton pour quitter qui s'ajuste à la largeur
            # de la fenêtre d'où le "int(larg/7)"
            Button(self.root, text="Quitter", bg="dark grey",
                   width = int(larg/7), command =
                   self.root.quit).pack(side = BOTTOM)
     
            # Appel la classe qui créera le joueur et le
            # positionne au centre
            Joueur(self.can, self.larg/2, self.haut-20)
            # Appel la classe qui va créé un météor
            Meteor(self.can)
     
        def mainloop(self):
            "Methode qui referme la fenetre"
            self.root.mainloop()
            self.root.destroy()
     
    if __name__ == "__main__":
     
        play = App(600, 600)
        play.mainloop()

  7. #7
    Membre averti
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    Mai 2013
    Messages
    54
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Canada

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Alimentation

    Informations forums :
    Inscription : Mai 2013
    Messages : 54
    Par défaut
    J'ai réécris mon code afin de lui enlever la class App, qui étais vraiment inutile comme tu m'avais dit, mais je reste toujours avec mon problème que je ne sais pas comment dire a l'ordi d'effacer les météorites quand il croise un projectiles

    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
     
    # -*- coding:Latin-1 -*-
     
    from tkinter import *
    from random import randrange
     
    class Meteor(object):
        """ Crée un météorite """
        def __init__(self, can):
     
            self.can = can
     
            # Récupère la taille du canvas
            self.tailleCanX = int(self.can.cget("width"))
            self.tailleCanY = int(self.can.cget("height"))
     
            # Génère une position X aléatoire
            self.posMX = randrange(5, self.tailleCanX-5)
     
            self.meteor = self.can.create_oval(self.posMX,
                                                    0,self.posMX+20, 20, fill = "white")
     
            self.deplaceMeteor()
            # Génére un nouveau météor
            self.can.after(1000, self.repete)
     
        def repete(self):
            """ Réappelle un Meteor """
            Meteor(self.can)
     
        def deplaceMeteor(self):
            """ Déplace le météor vers le bas du canvas """
     
            # Récupère la position du météor
            self.posM = self.can.coords(self.meteor)
            self.posMY = self.posM[1]
     
            # détruit le météor s'il sort du canvas
            if self.posMY < self.tailleCanY:
                self.can.move(self.meteor, 0, +
                              10)
                self.can.after(30, self.deplaceMeteor)
            else:
                self.can.delete(self.meteor)
     
    class Tire(object):
        """ Crée un projectile et le deplace """
        def __init__(self, can, posJoueur):
     
            self.can = can
     
            # Récupère la position du joueur
            self.posJoueur = posJoueur
            self.posJX = self.posJoueur[0]
            self.posJY = self.posJoueur[1]
     
            # Crée le projectile
            self.lazer = self.can.create_oval(self.posJX+5, self.posJY-10,
                                              self.posJX+15, self.posJY,
                                              fill = "blue")
     
            # Appel de la fonction qui deplace le projectile
            self.deplaceTire()
     
        def deplaceTire(self):
            " Déplace le projectile jusqu'en haut du canvas "
     
            # Récupère la position du projectile
            self.posLazer = self.can.coords(self.lazer)
            self.posLazerY = self.posLazer[1]
     
            # Détruit le lazer s'il sort du canvas
            if self.posLazerY > 0:
                self.can.move(self.lazer, 0, -10)
                self.can.after(30, self.deplaceTire)
            else:
                self.can.delete(self.lazer)
     
    class Joueur(object):
     
        def __init__(self, can):
     
            self.can = can
     
            # Récupère la taille du canvas
            self.canWidth = self.can.cget("width")
            self.canHeight = self.can.cget("height")
     
            # Converti la taille en chiffre (int) et positionne
            # player en centre du canvas
            self.posX = int(self.canWidth) / 2 - 10
            self.posY = int(self.canHeight) - 20
     
            self.player = self.can.create_rectangle(self.posX,
                                                    self.posY, self.posX+20,
                                                    self.posY+20, fill = "red")
     
            # Détection d'évènement
            self.can.bind("<Motion>", self.deplaceJoueur)
            self.can.bind("<1>", self.tire)
     
        def deplaceJoueur(self, event):
     
            # Récupère la position en X de la souri
            self.mouseX = event.x - 10 # -10 pour se centrer
     
            # Déplace player selon la souri
            self.can.coords(self.player, self.mouseX, self.posY,
                            self.mouseX+20, self.posY+20)
     
        def tire(self, event):
     
            # Récupère la position du joueur
            self.posJ = self.can.coords(self.player)
     
            # Appel de la class Tire avec position joueur
            Tire(self.can, self.posJ)
     
     
    if __name__ == "__main__":
     
        root = Tk()
     
        can = Canvas(root, width = 600, height = 600, bg = "black")
        can.pack()
     
        Button(root, text = "Quit", bg = "dark grey", command = root.quit,
               width = 600//7).pack(side = BOTTOM)
     
        Joueur(can)
        Meteor(can)
     
        root.mainloop()
        root.destroy()

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

Discussions similaires

  1. Réponses: 1
    Dernier message: 05/05/2009, 17h57
  2. probleme d'affichage sur objet TPaintBox
    Par Nephi dans le forum C++Builder
    Réponses: 2
    Dernier message: 04/07/2008, 11h41
  3. probleme sur objet excel application
    Par micka180 dans le forum VBScript
    Réponses: 3
    Dernier message: 04/10/2007, 10h54
  4. suivre un objet en mouvement sur image
    Par jlf dans le forum Traitement du signal
    Réponses: 24
    Dernier message: 09/05/2005, 13h46
  5. [UDP][Socket] perte de paquets et arret d'ecoute sur port
    Par Guismo1979 dans le forum Développement
    Réponses: 6
    Dernier message: 02/01/2003, 12h13

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