Listes.

Version imprimable

Bonjours à vous,

Je suis un développeur relativement débutant, et j'ai commencé un petit jeu 2D vue du dessus, cependant je suis tombé sur un bug que je ne comprend pas.
Dans le jeu, on est un smiley qui se déplace de case en case, et il y a des flèches qui se déplace dans leur direction toutes les 0,1 seconde, le bug étant que les flèches qui vont vers le bas et celles qui vont vers la droite se déplacent instantanément alors que les autres n'ont aucun problème.

Mon Threat et mon timer :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
Verrou = RLock()
 
class Timer_Fleche(Thread): #S'effectue en parallèle
 
    def __init__(self, Delais):
        Thread.__init__(self)
        self.Delais = Delais
 
    def run(self): #Fonction qui se répète chaque "Delais" seconde
        Start = time.time()
        while (1):
            if (time.time() - Start >= self.Delais):
                with Verrou: #Attendre que chaque dépacement s'effectue avant de continuer
                    Fleche_Mouvement()
 
                    Start = time.time()
 
#Mouvements :
    #Appel des threats :
        # Création des threads
Fleches = Timer_Fleche(0.1) # Les fleches bougent toutes les 0.1 secondes
        # Lancement des threads
Fleches.start()

Ma première fonction qui gère les flèches :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
def Fleche_Mouvement(): #Fonction pour bouger la totalité des fleches
    for i in range(625):
        if Fleche_Carre_Haut_Liste[i] != 0: #Fleche Carree Haut
            Fleche_Mouvement_2(i, 'FLECHE_CARRE_HAUT', Fleche_Carre_Haut_Liste, -25, 0, -20)
        elif Fleche_Carre_Bas_Liste[i] != 0: #Fleche Carree Bas
            Fleche_Mouvement_2(i, 'FLECHE_CARRE_BAS', Fleche_Carre_Bas_Liste, 25, 0, 20) # ---XBUGX---
        elif Fleche_Carre_Gauche_Liste[i] != 0: #Fleche Carree Gauche
            Fleche_Mouvement_2(i, 'FLECHE_CARRE_GAUCHE', Fleche_Carre_Gauche_Liste, -1, -20, 0)
        elif Fleche_Carre_Droite_Liste[i] != 0: #Fleche Carree Droite
            Fleche_Mouvement_2(i, 'FLECHE_CARRE_DROITE', Fleche_Carre_Droite_Liste, 1, 20, 0) # ---XBUGX---
        elif Fleche_Rond_Haut_Liste[i] != 0: #Fleche Ronde Haut
            Fleche_Mouvement_2(i, 'FLECHE_ROND_HAUT', Fleche_Rond_Haut_Liste, -25, 0, -20)
        elif Fleche_Rond_Bas_Liste[i] != 0: #Fleche Ronde Bas
            Fleche_Mouvement_2(i, 'FLECHE_ROND_BAS', Fleche_Rond_Bas_Liste, 25, 0, 20) # ---XBUGX---
        elif Fleche_Rond_Gauche_Liste[i] != 0: #Fleche Ronde Gauche
            Fleche_Mouvement_2(i, 'FLECHE_ROND_GAUCHE', Fleche_Rond_Gauche_Liste, -1, -20, 0)
        elif Fleche_Rond_Droite_Liste[i] != 0: #Fleche Ronde Droite
            Fleche_Mouvement_2(i, 'FLECHE_ROND_DROITE', Fleche_Rond_Droite_Liste, 1, 20, 0) # ---XBUGX---

Ma seconde fonction :

Code:

1
2
3
4
5
6
7
8
9
10
11
def Fleche_Mouvement_2(i, Objet, Objet_Liste, Direction, Mouvement_x, Mouvement_y): #Fonction pour bouger une fleche
    Position_Objet = DESSIN.coords(Objet_Liste[i])
    Case = Verification_Case(Position_Objet[0], Position_Objet[1])
    if Blocks_Liste[Case + Direction] == 'VOID':
        Blocks_Liste[Case] = "VOID"
        DESSIN.move(Objet_Liste[i], Mouvement_x, Mouvement_y)
        Position_Objet = DESSIN.coords(Objet_Liste[i])
        Case = Verification_Case(Position_Objet[0], Position_Objet[1])
        Blocks_Liste[Case] = Objet
        Objet_Liste[i + Direction] = Objet_Liste[i] #Replace l'objet au bon endroit dans sa liste
        Objet_Liste[i] = 0                          #L'enlève d'où il était avant

Quand je crée mes flèches :

Code:

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
    #Import du niveau:
Blocks_Liste = ["VOID"] * 625
Fleche_Rond_Haut_Liste = [0] * 625
Fleche_Rond_Bas_Liste = [0] * 625
Fleche_Rond_Gauche_Liste = [0] * 625
Fleche_Rond_Droite_Liste = [0] * 625
Fleche_Carre_Haut_Liste = [0] * 625
Fleche_Carre_Bas_Liste = [0] * 625
Fleche_Carre_Gauche_Liste = [0] * 625
Fleche_Carre_Droite_Liste = [0] * 625
Boite_Liste = [0] * 625
Toile_Liste = [0] * 625
Fichier = open("niveau_test.txt","r")
for i in range(25):
    OBJET = Fichier.readline()
    for l in range (25):
        if OBJET[l].count('S') == 1: #S = JOUEUR
            Smiley = DESSIN.create_image(l * 20 + 10, i * 20 + 10, image = Image_Smiley)
            Blocks_Liste[i*25 + l] = "SMILEY"
            DESSIN.tag_lower(Smiley)
        if OBJET[l].count('X') == 1: #X = MUR
            Mur = DESSIN.create_image(l * 20 + 10, i * 20 + 10, image = Image_Mur)
            Blocks_Liste[i*25 + l] = "MUR"
        if OBJET[l].count('O') == 1: #O = FLECHE ROND HAUT
            Fleche_Rond_Haut = DESSIN.create_image(l * 20 + 10, i * 20 + 10, image = Image_Fleche_Rond_Haut)
            Fleche_Rond_Haut_Liste[i*25 + l] = Fleche_Rond_Haut
            Blocks_Liste[i*25 + l] = "FLECHE_ROND_HAUT"
            DESSIN.tag_lower(Fleche_Rond_Haut)
        if OBJET[l].count('L') == 1: #L = FLECHE ROND BAS
            Fleche_Rond_Bas = DESSIN.create_image(l * 20 + 10, i * 20 + 10, image = Image_Fleche_Rond_Bas)
            Fleche_Rond_Bas_Liste[i*25 + l] = Fleche_Rond_Bas
            Blocks_Liste[i*25 + l] = "FLECHE_ROND_BAS"
            DESSIN.tag_lower(Fleche_Rond_Bas)
        if OBJET[l].count('K') == 1: #K = FLECHE ROND GAUCHE
            Fleche_Rond_Gauche = DESSIN.create_image(l * 20 + 10, i * 20 + 10, image = Image_Fleche_Rond_Gauche)
            Fleche_Rond_Gauche_Liste[i*25 + l] = Fleche_Rond_Gauche
            Blocks_Liste[i*25 + l] = "FLECHE_ROND_GAUCHE"
            DESSIN.tag_lower(Fleche_Rond_Gauche)
        if OBJET[l].count('M') == 1: #M = FLECHE ROND DROITE
            Fleche_Rond_Droite = DESSIN.create_image(l * 20 + 10, i * 20 + 10, image = Image_Fleche_Rond_Droite)
            Fleche_Rond_Droite_Liste[i*25 + l] = Fleche_Rond_Droite
            Blocks_Liste[i*25 + l] = "FLECHE_ROND_DROITE"
            DESSIN.tag_lower(Fleche_Rond_Droite)
        if OBJET[l].count('Y') == 1: #Y = FLECHE CARREE HAUT
            Fleche_Carre_Haut = DESSIN.create_image(l * 20 + 10, i * 20 + 10, image = Image_Fleche_Carre_Haut)
            Fleche_Carre_Haut_Liste[i*25 + l] = Fleche_Carre_Haut
            Blocks_Liste[i*25 + l] = "FLECHE_CARRE_HAUT"
            DESSIN.tag_lower(Fleche_Carre_Haut)
        if OBJET[l].count('H') == 1: #H = FLECHE CARREE BAS
            Fleche_Carre_Bas = DESSIN.create_image(l * 20 + 10, i * 20 + 10, image = Image_Fleche_Carre_Bas)
            Fleche_Carre_Bas_Liste[i*25 + l] = Fleche_Carre_Bas
            Blocks_Liste[i*25 + l] = "FLECHE_CARRE_BAS"
            DESSIN.tag_lower(Fleche_Carre_Bas)
        if OBJET[l].count('G') == 1: #G = FLECHE CARREE GAUCHE
            Fleche_Carre_Gauche = DESSIN.create_image(l * 20 + 10, i * 20 + 10, image = Image_Fleche_Carre_Gauche)
            Fleche_Carre_Gauche_Liste[i*25 + l] = Fleche_Carre_Gauche
            Blocks_Liste[i*25 + l] = "FLECHE_CARRE_GAUCHE"
            DESSIN.tag_lower(Fleche_Carre_Gauche)
        if OBJET[l].count('J') == 1: #J = FLECHE CARREE DROITE
            Fleche_Carre_Droite = DESSIN.create_image(l * 20 + 10, i * 20 + 10, image = Image_Fleche_Carre_Droite)
            Fleche_Carre_Droite_Liste[i*25 + l] = Fleche_Carre_Droite
            Blocks_Liste[i*25 + l] = "FLECHE_CARRE_DROITE"
            DESSIN.tag_lower(Fleche_Carre_Droite)
        if OBJET[l].count('B') == 1: #B = Boite
            Boite = DESSIN.create_image(l * 20 + 10, i * 20 + 10, image = Image_Boite)
            Boite_Liste[i*25 + l] = Boite
            Blocks_Liste[i*25 + l] = "BOITE"
            DESSIN.tag_lower(Boite)
        if OBJET[l].count('T') == 1: #T = Toile
            Toile = DESSIN.create_image(l * 20 + 10, i * 20 + 10, image = Image_Toile)
            Toile_Liste[i*25 + l] = Toile
            Blocks_Liste[i*25 + l] = "TOILE"
            DESSIN.tag_lower(Toile)
Fichier.close()

J'utilise plusieurs listes (par type) pour stocker mes objets (forme : "0,0,0,0,56,0,42,0...", et une liste générale (Forme : "MUR,MUR,MUR,VOID,FLECHE_CARRE_HAUT,MUR...), qui vont chacune de la gauche vers la droite, et du haut vers le bas, mon jeu fait 25*25 cases (exemple, si une flèche est à la 28ème valeur, il sera à la position (3, 2), chaque case fait 20 pixels.

Mais là où je ne comprend pas, c'est que seulement les flèches avec des déplacements positifs bugs, j'ai cherché longtemps la cause du problème mais rien.

Évidamment j'ai fais des tests :

* En enlevant :

Code:

1
2
Objet_Liste[i + Direction] = Objet_Liste[i] #Replace l'objet au bon endroit dans sa liste
        Objet_Liste[i] = 0                          #L'enlève d'où il était avant

cela marche (mais j'en ai besoin pour récupérer la position de chaque objet).

* En mettant un "-" devant les valeurs, étrangement ça marche plutôt bien, les flèches se déplacent à la bonne vitesse (même si tout est deréglé au niveau des positions).

* Avec un print j'ai pu voir que les flèches se déplacent bien case par case (mais en oubliant le timer ?)

Je m'en remets à vous :zoubi:, je ne comprend absolument pas ce bug, surtout qu'il n'y a un problème que pour les chiffres positifs.
Je peux mettre le reste du code si besoin.

30/12/2016, 06h39
tyrtamos

Bonjour,

Il n'est pas précisé quelle bibliothèque graphique est utilisée (tkinter?), mais la plupart d'entre elles ne sont pas "thread safe", c'est à dire que le code d'un thread ne doit pas toucher directement la partie graphique. Si on le fait quand même, cela donne des dysfonctionnements aléatoires qui sont difficiles à comprendre et à déboguer.

Selon la bibliothèque, on passe par l'intermédiaire d'une queue ou d'un signal émis par le thread, et c'est la partie principale du programme qui modifie le graphique en fonction.

Salut,

Quand vous racontez:

Citation:

Envoyé par Dragolden

J'utilise plusieurs listes (par type) pour stocker mes objets (forme : "0,0,0,0,56,0,42,0...", et une liste générale (Forme : MUR,MUR,MUR,VOID,FLECHE_CARRE_HAUT,MUR...), qui vont chacune de la gauche vers la droite, et du haut vers le bas, mon jeu fait 25*25 cases (exemple, si une flèche est à la 28ème valeur, il sera à la position (3, 2), chaque case fait 20 pixels.

et qu'on lit le code, difficile de ne pas penser "pourquoi si compliqué?"

ok vous l'expliquez:

Citation:

Envoyé par Dragolden

Je suis un développeur relativement débutant, et j'ai commencé un petit jeu 2D vue du dessus, cependant je suis tombé sur un bug que je ne comprend pas.

Si vous vous lancez dans la construction de choses complexes en généralisant des constructions simplistes, vous obtiendrez un code qui fonctionnera pourvu que vous ne vous découragiez pas à arriver à le faire tomber en marche.

Relisez votre code!
Côté threads:
Code:

1 2 3 4 5 6 7 8 def run(self): #Fonction qui se répète chaque "Delais" seconde Start = time.time() while (1): if (time.time() - Start >= self.Delais): with Verrou: #Attendre que chaque dépacement s'effectue avant de continuer Fleche_Mouvement() Start = time.time()
c'est une boucle qui ne fait rien sinon bouffer du CPU en appelant time.time() juste pour attendre self.Delais. Bien sûr çà fonctionne mais time.sleep(self.Delais) le ferait aussi bien sans bouffer un CPU... ce qui dans le cas particulier de Python est important à cause du GIL.

Mais comme l'a fait remarquer Tyrtamos, threads et bibliothèques graphiques se mélangent assez mal. Et même si c'est supporté par Tkinter, on évite... car en cas de problèmes, on regardera rarement plus loin.

Regardez aussi:
Code:

1 2 3 4 5 6 7 8 9 10 11 def Fleche_Mouvement_2(i, Objet, Objet_Liste, Direction, Mouvement_x, Mouvement_y): #Fonction pour bouger une fleche Position_Objet = DESSIN.coords(Objet_Liste[i]) Case = Verification_Case(Position_Objet[0], Position_Objet[1]) if Blocks_Liste[Case + Direction] == 'VOID': Blocks_Liste[Case] = "VOID" DESSIN.move(Objet_Liste[i], Mouvement_x, Mouvement_y) Position_Objet = DESSIN.coords(Objet_Liste[i]) Case = Verification_Case(Position_Objet[0], Position_Objet[1]) Blocks_Liste[Case] = Objet Objet_Liste[i + Direction] = Objet_Liste[i] #Replace l'objet au bon endroit dans sa liste Objet_Liste[i] = 0 #L'enlève d'où il était avant
Dans cette histoire, vous avez le canvas qui a une idée de la position des objets et vos listes qui devraient dupliquer fidèlement ces informations.
Donc quelque part, osez écrire:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 def Fleche_Mouvement_2(i, Objet, Objet_Liste, Direction, Mouvement_x, Mouvement_y): #Fonction pour bouger une fleche Position_Objet = DESSIN.coords(Objet_Liste[i]) Case = Verification_Case(Position_Objet[0], Position_Objet[1]) assert Case == i if Blocks_Liste[Case + Direction] == 'VOID': Blocks_Liste[Case] = "VOID" DESSIN.move(Objet_Liste[i], Mouvement_x, Mouvement_y) Position_Objet = DESSIN.coords(Objet_Liste[i]) Case = Verification_Case(Position_Objet[0], Position_Objet[1]) assert Case == i + Direction Blocks_Liste[Case] = Objet Objet_Liste[i + Direction] = Objet_Liste[i] #Replace l'objet au bon endroit dans sa liste Objet_Liste[i] = 0 #L'enlève d'où il était avant
i.e. assurez vous que la cohérence nécessaire pour que çà fonctionne est réalisée.

Après il faut simplifier... Et pour çà éviter de dupliquer des informations que vous pouvez stocker et récupérer depuis le Canvas.
La première simplification serait de virer toutes ces listes en utilisant des tags.
Exemple, un truc comme:
Code:

1 2 3 4 5 if OBJET[l].count('O') == 1: #O = FLECHE ROND HAUT Fleche_Rond_Haut = DESSIN.create_image(l * 20 + 10, i * 20 + 10, image = Image_Fleche_Rond_Haut) Fleche_Rond_Haut_Liste[i*25 + l] = Fleche_Rond_Haut Blocks_Liste[i*25 + l] = "FLECHE_ROND_HAUT" DESSIN.tag_lower(Fleche_Rond_Haut)
deviendrait:
Code:

1 2 3 if OBJET[l].count('O') == 1: #O = FLECHE ROND HAUT iid = DESSIN.create_image(l * 20 + 10, i * 20 + 10, image = Image_Fleche_Rond_Haut, tags=('fleche', 'fleche_rond_haut')) DESSIN.tag_lower(iid)
ce qui permet dans Fleche_Mouvement d'en récupérer les identifiants via .find_withtag('fleche') ou .find_withtag('fleche_rond_haut').

Dit autrement, utiliser mieux les fonctionnalités du Canvas, c'est écrire moins de code... et moins de de bugs (que pas grand monde ira/pourra corriger...).

- W

Merci à vous :)

Je vais refaire une partie de mon code avec les tags, mais il me manque juste à savoir comment obtenir la taille d'un tag, pour le moment j'ai ça :

Code:

1
2
3
4
5
6
7
8
9
10
def Fleche_test():
    for i in range(4):
        Position_Objet = DESSIN.coords(DESSIN.find_withtag('Fleche_Rond_Haut')[i])
        Case = Verification_Case(Position_Objet[0], Position_Objet[1])
        if Blocks_Liste[Case + -25] == 'VOID':
            Blocks_Liste[Case] = "VOID"
            DESSIN.move(DESSIN.find_withtag('Fleche_Rond_Haut')[i], 0, -20)
            Position_Objet = DESSIN.coords(DESSIN.find_withtag('Fleche_Rond_Haut')[i])
            Case = Verification_Case(Position_Objet[0], Position_Objet[1])
            Blocks_Liste[Case] = "FLECHE_ROND_HAUT"

Je voudrais simplement remplacer le 4 par la taille du tag en question, mais .length ne marche pas.

30/12/2016, 17h04
wiztricks

Citation:

Envoyé par Dragolden

Je vais refaire une partie de mon code avec les tags, mais il me manque juste à savoir comment obtenir la taille d'un tag, pour le moment j'ai ça

Si vous utilisez des tags, vous pouvez déplacer tous les objets qui ont un même tag sans vous em.. à en récupérer l'identifiant: DESSIN.move('Fleche_Rond_Haut', 0, -20).
Dans votre code actuel les déplacements haut, bas, gauche, droite sont identiques pour fleche carree ou ronde. Donc... DESSIN.move('haut', 0, -20) va déplacer vers le haut toutes les flèches carrées et rondes d'un seul coup.

Intuitivement, vos tags vont désigner des catégories d'objets auxquels vous allez pouvoir appliquer la même méthode. C'est puissant mais il faut prendre le temps de jouer avec cette fonctionnalité là (et définir les bonnes catégories): vous allez certainement vouloir détecter des collisions ou des positions particulières.

La documentation est (par exemple) ici mais vous avez du temps à passer pour remettre en forme la conception de votre code avec cette fonctionnalité là et surtout écrire de petits exemples illustrant/réalisant les différents cas qui vous intéressent.

- W
30/12/2016, 20h43
Dragolden

1 pièce(s) jointe(s)

Changement terminé ! ;)

Ça m'a pris du temps mais il marche parfaitement (pour le moment du moins, héhé), un petit screen de la première version clean pour vous remercier :

Pièce jointe 231333