[PYTHON] Correction bug

[Scryper]

Bonjour,

Je code depuis quelques temps un projet en python, c'est un projet nommé "jeu des bombardes" où, pour le moment, un canon tire autour de lui. (Je compte apporter beaucoup d'améliorations).
J'ai donc demandé sur le forum physique d'Open Classrooms une formule pour calculer la trajectoire de l'obus.

La formule que l'on m'a donnée était bonne, mais j'avais quelques petits problèmes : d'abord, l'obus était décalé par rapport à la bouche du canon pour toutes les valeurs d'angles (sauf 0° et 360°).
Ensuite, l'obus ne partait jamais vers la gauche du Canvas même si c'est là que je visait.

Mais je n'ai plus aucune aide de leur part depuis le mois de décembre...

Alors, j'ai finalement opté pour autre chose : choisir une vitesse et en calculer ses composantes. J'ai eu une petite amélioration : l'obus peut partir n'importe où dans le Canvas. Mais il est toujours décalé par rapport à la bouche du canon...Je pensais que c'était dû aux formules donc j'ai demandé sur le forum physique de ce site-ci, et un des utilisateurs m'a orienté ici.

Pour ne pas m'étaler encore en longueur, voici le lien où le plus important se trouve. Les pages d'avant concernent d'autres problèmes, qui ont étés réglés.

N'hésitez pas si vous avez besoin d'infos en plus.

Merci.
-----

[LeMulet]

Je reprends le code :

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

Je ne connais pas le Python donc je peux me tromper.(je suis quand même allé voir la syntaxe des tests conditionnels)

Néanmoins, il y a quelque-chose qui m'intrigue ici :
A la ligne 23 le canvas de l'obus est supprimé juste après sa première (et dernière...) création qui se fait à la ligne 06
Puisque le else de la ligne 22 correspond au cas où self.verifier()=false, ce qui est le cas si on est passé par la ligne 06.
Ca peut expliquer l'absence d'affichage de l'obus, puisqu'au prochain appel de feu(self), self.creer étant égal à true, on ira uniquement à la ligne 13, et que le canvas ne sera pas créé mais on va pourtant tenter des opérations sur le canvas, par exemple canv.move, canv.update.
C'est amusant d'ailleurs que python ne se plaint pas (il est trop docile le Python ).

[CM63]

Bonjour,

J'espère que self.creer est une donnée membre et non une méthode, puisque tu l'appelles sans parenthèses. Et corrélativement j'espère que self.verifier() est une méthode et non une donnée membre puisque tu l'appelles avec des parenthèses. Mais bon , je sens l'erreur, ça m'étonne un peu que l'une soit une méthode et l'autre une donnée, à vérifier.

[Scryper]

Bonjour,

CM63 :
Oui, verifier() est une fonction et creer est une variable initialisée à True.

LeMulet :
Je pense que tu n'as pas trop compris (je te réexplique au cas où, mais peut-être que tu as compris, je ne sais pas).
Le premier if : si aucun obus n'est présent sur le canvas, je crée l'obus. C'est pour empêcher de tirer 463450 fois alors que le premier obus n'a pas fini sa course (je dois encore vérifier si ça fonctionne correctement, mais je vais d'abord m'occuper du problème de décalage). Et je calcule les composantes verticales et horizontales de la vitesse.
Le deuxième : tant que l'obus n'a pas touché de bord (c'est ce que fait ma méthode verifier()), je continue à calculer les différentes positions de l'obus pendant sa course.
Le else : je détruit l'obus, vu qu'il a touché un bord et je réinitialise les variables dont j'ai besoin pour le prochain tir.

Ensuite : "Ca peut expliquer l'absence d'affichage de l'obus, puisqu'au prochain appel de feu(self), self.creer étant égal à true, on ira uniquement à la ligne 13, et que le canvas ne sera pas créé mais on va pourtant tenter des opérations sur le canvas, par exemple canv.move, canv.update." Il n'y a pas d'absence d'affichage, toutes les positions sont affichées. Le problème, c'est que l'obus est décalé par rapport à la bouche du canon. Et au prochain appel de feu() (ligne21), creer sera égal à False (ligne 10) donc on ne créée rien de nouveau ; on modifie ce qui est présent car ce n'est pas un Canvas que je créée ligne 6, c'est un élément que j'ajoute sur un canvas déjà présent sur le programme principal.

Pour faire plus simple voici le programme principal et mon module :

# -*- coding : utf-8 -*-
from tkinter import *
from canon import *  # c'est le morceau de code suivant

# Démarrage et options de la musique de fond de base (on pourra la changer pendant le jeu)
#pygame.mixer.init()
#pygame.mixer.music.load('C:\\Users\\Mazzeo Roberto\\Desktop\\Florian\\Ressources PB\\Chant Militaire.ogg')

# Création de la fenêtre, avec options
fen = Tk()
fen.title("Jeu des bombardes")
fen.geometry("516x700")
fen.resizable(width = False, height = False)

# La musique commence
#pygame.mixer.music.play(9)

# Création de cadres, pour que l'interface ne soit pas trop simpliste
f1 = Frame(fen, borderwidth = 2, relief = SUNKEN)
f1.place(x = 2, y = 550)

f2 = Frame(fen, borderwidth = 3, relief = SUNKEN)
f2.place(x = 2, y = 3)

# Utilisation des classes indispensables
Canv = Canvas(f2, bg = "ivory", width = 500, height = 500)      # Ajout du Canvas pour l'interface de jeu
Canv.pack(padx = 1, pady = 1)   # Placement du Canvas

can = Canon(Canv, 250, 250, fen)     # On utilise ma classe :-P, les deux nombres sont les coordonées de départ du canon

bur = Bureau(can, f1)       # Création du bureau, l'interface de commande du joueur (c'est aussi ma classe B-))

label = Label(fen, text = 'Interface joueurs', font = ('Arial', 15)).place(x = 180, y = 516)

opts = Options(fen, 10, 518)    # Accès aux options (ça aussi c'est moi qui l'ai fait), les deux nombres sont les coordonnées du bouton

fen.mainloop()
pygame.mixer.music.stop()       # La musique s'arrête quand la fenêtre est fermée

# -*- coding : utf-8 -*-
from tkinter import *
from math import *
from time import *
import pygame.mixer

class Bureau() :
    """Création d'une classe pour le placement du "bureau" du joueur
    Le bureau comprend : - un widget Scale pour l'orientation de la buse
                         - un bouton pour déclencher le tir"""
    def __init__(self, Can, Fra1) :
        self.Fra1 = Fra1
        self.Can = Can
        # Placement du widget scale pour l'orientation de la buse
        self.orient = Scale(self.Fra1, from_ = 0, to = 360, orient = VERTICAL, tickinterval = 180, command = self.Can.orientation)
        self.orient.pack(padx = 1, pady = 1)
        # Placement du bouton pour tirer
        self.BTir = Button(self.Fra1, text = "FEU !", width = 5, command = self.Can.feu)
        self.BTir.pack(padx = 1, pady = 5)

class Canon() :
    """Création du canon et de la fonctionnalité d'ajustement de la buse."""
    # Création du canon
    def __init__(self, Canv, x, y, fen) :
        self.Canv = Canv
        self.x1, self.y1 = x, y
        self.fen = fen
        # Création de la buse du canon
        self.lbu = 40
        self.x2, self.y2 = x + self.lbu, y
        self.buse = self.Canv.create_line(self.x1, self.y1, self.x2, self.y2, width = 15)
        # Création du corps du canon
        r = 15
        self.Canv.create_oval(self.x1 - r, self.y1 - r, self.x1 + r, self.y1 + r, fill = "black", width = 3)
        self.creer = True
        self.augmentationCV = 0

    def orientation(self, angle) :         # Création de la fonction pour orienter la buse du canon
        """Orientation de la buse du canon pour choisir l'angle de tir."""
        self.ang = float(angle) * 2 * pi / 360    # Conversion de la chaine de caractère 'angle' en valeur numérique, puis en radians
        self.x2 = self.x1 + self.lbu * cos(self.ang)
        self.y2 = self.y1 + self.lbu * sin(self.ang)
        self.Canv.coords(self.buse, self.x1, self.y1, self.x2, self.y2)

    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")   # print de vérification (à supprimer)
            return False
        else :
            print("ok")   # print de vérification (à supprimer)
            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.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 = -10 * sin(self.ang)
            self.ch = 10 * 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

class Options() :
    """Création du menu des options.
    Possibilités : - différentes musiques"""
                   #- on peut changer les couleurs de l'interface de jeu    --> plus tard
                   #(couleurs du canon, du fond du Canvas,...)"""
    def __init__(self, matrice, x, y) :
        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.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\\Rap God.ogg', 'C:\\Users\\Mazzeo Roberto\\Desktop\\Florian\\Ressources PB\\Lose Yourself.ogg',
        'C:\\Users\\Mazzeo Roberto\\Desktop\\Florian\\Ressources PB\\Blessings.ogg', "C:\\Users\\Mazzeo Roberto\\Desktop\\Florian\\Ressources PB\\I Don't Fuck With You.ogg",
        'C:\\Users\\Mazzeo Roberto\\Desktop\\Florian\\Ressources PB\\Born Again.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 options(self) :
        # Création de la fenêtre des options, avec...options :-P
        self.f2 = Tk()
        self.f2.title("Options")
        self.OptsMus = Button(self.f2, text = 'Changer la musique', command = self.OptsMusique).pack()   # bouton pour accéder aux options de la musique du jeu (10 disponibles)
        self.f2.mainloop()

    def OptsMusique(self) :
        self.f3 = Tk()  # création d'une fenêtre pour choisir la musique de fond
        self.f3.title("Changer la musique")                    #
        self.f3.geometry('266x142')                            # ==> options de la fenêtre
        self.f3.resizable(width = False, height = False)       #
        MusiqueDeBase = Button(self.f3, 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.f3, text = 'Black beatles', width = 17, command = lambda : self.musique(1)).place(x = 2, y = 30)
        Eminem1 = Button(self.f3, text = 'Rap god', width = 17, command = lambda : self.musique(2)).place(x = 2, y = 58)
        Eminem2 = Button(self.f3, text = 'Lose yourself', width = 17, command = lambda : self.musique(3)).place(x = 2, y = 86)
        BigSean1 = Button(self.f3, text = 'Blessings', width = 17, command = lambda : self.musique(4)).place(x = 2, y = 114)
        BigSean2 = Button(self.f3, text = "I don't fuck with you", width = 17, command = lambda : self.musique(5)).place(x = 135, y = 2)
        Ahzee1 = Button(self.f3, text = 'Born again', width = 17, command = lambda : self.musique(6)).place(x = 135, y = 30)
        Ahzee2 = Button(self.f3, text = 'Go Gyal', width = 17, command = lambda : self.musique(7)).place(x = 135, y = 58)
        Desiigner = Button(self.f3, text = 'Tiimmy turner', width = 17, command = lambda : self.musique(8)).place(x = 135, y = 86)
        DVegasETLMike = Button(self.f3, text = 'The melody', width = 17, command = lambda : self.musique(9)).place(x = 135, y = 114)
        self.f3.mainloop()

    def musique(self, pos) :
        pygame.mixer.music.load(self.sons[pos])   # chargement de la musique
        pygame.mixer.music.play()   # la musique est jouée

[A voir en vidéo sur Futura]

[LeMulet]

Ok, je vois mon erreur pour self.verifier() et effectivement ça devrait fonctionner.

Par contre concernant le décalage de l'obus il y a une ligne de code qui me parait suspecte :

self.obus = self.Canv.create_oval(self.x1 + r, self.y1 + r, self.x2 - r, self.y2 - r, fill = "black")

Si j'ai bien compris la coordonnée self.x1 et self.y1 est censée être la base de la buse du canon
Puisqu'on a cette partie du code pour la buse.

        # Création de la buse du canon
        self.lbu = 40
        self.x2, self.y2 = x + self.lbu, y
        self.buse = self.Canv.create_line(self.x1, self.y1, self.x2, self.y2, width = 15)

Donc on devrait plutot avoir le code suivant :

self.obus = self.Canv.create_oval(self.x2 + r, self.y2 + r, self.x2 - r, self.y2 - r, fill = "black")

Comme ça on centre sur x2/y2 qui est la Coordonnée de la fin de la ligne d'épaisseur 15 représentant la buse.

[Scryper]

Bonjour,

ton aide à eu un effet positif : l'obus était devenu ovale il y a quelques temps, et c'est revenu à la normale.
Donc le dernier problème c'est que l'obus ne part pas souvent où le canon pointe, parfois c'est proche, parfois c'est totalement écarté. Mais ça c'est quelque chose à arranger dans le forum physique non ?

Merci !

[LeMulet]

Un (ou deux ?) problème de réglé donc.

Donc le dernier problème c'est que l'obus ne part pas souvent où le canon pointe, parfois c'est proche, parfois c'est totalement écarté.

Mais ça c'est quelque chose à arranger dans le forum physique non ?

C'est pas très clair (et je ne pense pas de toutes façons qu'on soit dans un cas où on aurait besoin de faire des calculs physiques, juste à employer les bonne variations par itération).

L'obus ne part pas de la pointe de la buse (au moment ou on fait feu), ou c'est la trajectoire (le chemin parcouru par l'obus) de l'obus qui est fausse ? (par exemple il part vers gauche alors que la buse pointe à droite)
Ou les deux ?

[Scryper]

C'est principalement la trajectoire qui est mauvaise. Par exemple, je vise vers le bas et l'obus monte un peu vers le haut avant de chuter quasiment verticalement. Et parfois, comme tu l'as dit, je vise à droite et l'obus part vers la gauche. Alors que il part dans le bon sens certaines fois.

Et parfois la trajectoire part directement de la base du canon.

Merci.

[LeMulet]

C'est principalement la trajectoire qui est mauvaise. Par exemple, je vise vers le bas et l'obus monte un peu vers le haut avant de chuter quasiment verticalement. Et parfois, comme tu l'as dit, je vise à droite et l'obus part vers la gauche. Alors que il part dans le bon sens certaines fois.

D'accord.
Donc au niveau de la direction déjà :

            # Composantes verticales et horizontales de la vitesse de l'obus :
            self.cv = -10 * sin(self.ang)
            self.ch = 10 * cos(self.ang)

self.ch c'est la variation en X et self.cv c'est la variation en Y.
Il y a a mon avis une erreur si je suppose que les coordonnées de l'écran commencent en 0.0 en bas à gauche.
On devrait avoir le même calcul que lorsqu'on trace la ligne de la buse.

Le code devrait dont être :

            # Composantes verticales et horizontales de la vitesse de l'obus :
            self.cv =  10 * sin(self.ang)
            self.ch = 10 * cos(self.ang)

Donc ça, c'est le vecteur vitesse de l'obus.

A partir de là, il faut être clair sur ce qu'on voit à l'écran.
Je comprend (mais je peux me tromper) qu'on voit en coupe le canon qui est disposé au centre de l'écran.
C'est à dire que l'obus devra "tomber" vers le bas.

Pour la trajectoire, si on veut quelque-chose d'à peu près réaliste, on va faire une parabole (non amortie pour simplifier).
Physiquement parlant ça veut dire que la vitesse horizontale ne change pas, mais que la vitesse verticale "décroit" au cours du temps.

Donc là du coup, le code suivant est faux.

       # 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.ch ne doit pas changer.
De plus la variation de self.cv n'est pas dans le bon sens (si les coordonnées de l'écran sont 0/0 en bas à gauche, sinon ne pas prendre en compte cette remarque)
Et self.augmentationCV ne doit pas changer non plus, c'est la variation de cv, qui doit être fixe.
Cette valeur correspond ici à l'accélération terrestre, qui "tire vers le bas", c'est la variation de la composante verticale de la vitesse.

Le code est donc plus simple et devrait donc plutôt être :

       # 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.cv -= self.augmentationCV

A tester donc, mais je pense qu'on ne devrait plus être très loin du résultat.

[Scryper]

D'accord.
Donc au niveau de la direction déjà :

            # Composantes verticales et horizontales de la vitesse de l'obus :
            self.cv = -10 * sin(self.ang)
            self.ch = 10 * cos(self.ang)

self.ch c'est la variation en X et self.cv c'est la variation en Y.
Il y a a mon avis une erreur si je suppose que les coordonnées de l'écran commencent en 0.0 en bas à gauche.

Non, en python (0;0) se trouve en HAUT à gauche. D'où le -10 pour calculer la composante verticale (il faut "inverser" le graphique).

Tu dis : "Pour la trajectoire, si on veut quelque-chose d'à peu près réaliste, on va faire une parabole (non amortie pour simplifier).
Physiquement parlant ça veut dire que la vitesse horizontale ne change pas, mais que la vitesse verticale "décroit" au cours du temps." et que le code est faux. Mais c'est seulement dans le cas où je vise vers le bas ou pas ?

Je vais tester ce que tu dis et j'éditerai ce post quand ce sera fait.

Merci !

[Scryper]

Je viens de tester, et la courbe est inversée. Donc, au lieu que l'obus ne tombe vers le bas, il monte vers le haut. Et du coup c'est beaucoup moins réaliste

[LeMulet]

Mais c'est seulement dans le cas où je vise vers le bas ou pas ?

Non, c'est toujours comme ça, la variation de la vitesse est constante (c'est l'accélération de la pesanteur).
Donc pour finaliser, conserve le -10 et remet +=. (ou change le signe de augmentationCV, (moi j'aurais fait comme ça))
Mais ne fais pas varier augmentationCV.

C'est presque bon.

[Scryper]

En effet, c'est presque bon.

La trajectoire est meilleure, moins souvent totalement décalée. Mais il y a quand même certaines fois (par exemple 95°, je vise vers le bas) et bien l'obus part vers le haut.

Merci !

[Scryper]

Je viens de remarquer que quand je vise vers le bas, l'obus part vers le haut et inversement ! Qu'est-ce que je dois changer dans ce cas ? J'ai l'impression que c'est un tout petit truc à changer mais le temps que je cherche, on ne sait jamais si vous trouvez avant moi ?

EDIT : J'ai trouvé, j'ai retiré le - devant le calcul de self.cv et c'est bon : plus aucun décalage, RIEN !

Merci beaucoup !

[LeMulet]

Je viens de remarquer que quand je vise vers le bas, l'obus part vers le haut et inversement ! Qu'est-ce que je dois changer dans ce cas ? J'ai l'impression que c'est un tout petit truc à changer mais le temps que je cherche, on ne sait jamais si vous trouvez avant moi ?

EDIT : J'ai trouvé, j'ai retiré le - devant le calcul de self.cv et c'est bon : plus aucun décalage, RIEN !

Merci beaucoup !

Je suis content de voir que ça tourne.
Bonne continuation.

[Scryper]

Bonjour,

Je reviens vers vous pour quelques questions. Et parce que vous répondez plus vite que ceux d'OC et donc je peux avancer plus vite

Quand l'obus est détruit, dans le code actuel, il est simplement détruit du Canvas. Mais j'aimerais créer une 'animation' d'explosion.
En fait, lorsque l'obus touchera un bord, ou plus tard un adversaire, j'aimerais que, à partir du centre du boulet, d'autres petits cercle de rayon 1 partent depuis le centre du cercle pour avancer de quelques pixels.
Donc, voici ma question :

Comment je récupère les coordonées du centre du cercle ?

Merci !

[LeMulet]

Le centre du boulet, c'est le centre du canvas du boulet.
Donc, par exemple, comme c'est fait lors du test, on a les coordonnées self.x1_ob, self.y1_ob si, self.x2_ob, self.y2_ob qui définisent le canvas du boulet.

Le centre x/y du canvas, c'est :
x= (self.x1_ob + self.x2_ob) * 0.5
et
y= (self.y1_ob + self.y2_ob) * 0.5

Je ne sais pas si ça répond à la question ?