demande de conseille pour un probleme sur une fonction [Résolu]

[pierre-y]

Bonjour,

Je suis en train de finir mon premier programme en python mais j'aurais besoin de conseille sur des pistes que je pourrais suivre concernant un problème sur une fonction.

Le programme que j’essaie de créer est un outil de mise en forme de tileset (un bitmap qui contient toute les tuile graphique nécessaire a la création d'un niveau pour un jeux 2D (zelda,...).

J'ai joins le programme si vous voulez l'essayer et me donner votre avis (il a été fait sur python 2.7).
il autorise 3 import:
-le tileset qui est ouvert directement dans l’éditeur
-la map qui une fois ouverte demande que l'on choisisse la taille des tuiles a générer a partir de celle ci(le bouton généré s'active a l'ouverture). Les tuiles cette fois sont trillé pour éviter les redondance

c'est la troisième qui me pose problème.
Celle ci permet normalement d'importer un tileset et son CSV et de reformer des tiles a partir de celle ci avec un CSV qui lui est associé. Un schéma sera plus clair.

un tilse composé de 4*2 tiles au format 8*8pixels par exemple

0123
4567

son CSV qui permet de créer la map associé au tileset en haut

0,1,3,5
2,3,5,4
0,7,6,5

si je demande des tiles de 3*3pixels par exemple, la fonction va redécouper la map en fonction de cette taille demandé est recréer un tilseset et un CSV en accord avec ça.



Mon problème vient du fait que la fonction de prend pas en compte toute les tiles d'une map pour générer le nouveau tilesetet son CSV. CA marche bien pour de petite map comme "Tiletest" dans le dossier, mais des que ça devient plus grand toute les tuiles ne sont pas prie compte, comme "plateau_tiles"(joins lui aussi).


La, je vois pas du tout d’où ça viens. Pourriez vous me donner des pistes pour essayer de le résoudre? Y'a t'il un paramètre dans python que je n'ai pas prie en compte(approximation,limite,..).


information utile:
LtTset est la liste des bitamp fournie a la fonction sous forme de numpyArray
LtCSV est le CSV qui lui est associé fournie lui aussi sous forme de liste.

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
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
196
197
198
199
200
201
202
203
204
 
    def parse_CSV(self,LtTset, LtCSV, TWgen=0, THgen=0, direct_gen=0):
        print'--------------------------------------------------------'
        print 'fct parse_CSV lance'
 
        if(LtTset and LtCSV):
 
                #print'LtTset : '+str(LtTset)
                #print'LtCSV : '+str(LtCSV)
 
                #on récupère les données des deux liste tile et csv import
 
                #ListTset liste de bitmap donné sous forme de numpyarray
                #ListCSVimp le CSV qui lui est associé est qui permet de creer la map
 
                ListTset=LtTset
                TileWts,TileHts=LtTset[0].shape[0],LtTset[0].shape[1]
                Tiles_tsW=self._importTilesTsW#creer une classe tileset
                Tiles_tsH=self._importTilesTsH
 
                ListCSVimp=LtCSV
                Tiles_CSVimpW=len(ListCSVimp[0])
                Tiles_CSVimpH=len(ListCSVimp)
                CSVimpW=Tiles_CSVimpW*TileWts
                CSVimpH=Tiles_CSVimpH*TileHts
 
                print''
                print 'TileWts,TileHts : '+str(TileWts)+' , '+str(TileHts)
                print 'Tiles_tsW,Tiles_tsH : '+str(Tiles_tsW)+' , '+str(Tiles_tsH)
                print 'total Tiles_ts : '+str(Tiles_tsW*Tiles_tsH)
 
                print 'Tiles_CSVimpW, Tiles_CSVimpH : '+str(Tiles_CSVimpW)+' , '+str(Tiles_CSVimpH)
                #print 'LtCSV : '+str(LtCSV)
                print''
                print'-----------------------'
 
                #format des nouvelles tiles a generer a genrer
                TileWgen, TileHgen = TWgen, THgen
                print 'TileWgen, TileHgen : '+str(TileWgen)+' , '+str(TileHgen)
 
                print''
 
                a=1 #temp
 
                #if(not(direct_gen) and ((TileWgen !=0 and TileHgen !=0) and (TileWts != TileWgen or TileHts !=TileHgen))):
                if(a):#temp
 
                        print 'parse CSV se lance'
 
                        #mapGen
                        if(TileWgen==0):
                                TileWgen=TileWts
                        if(TileHgen==0):
                                TileHgen=TileHts
 
                        Tiles_mapGenW=int((len(ListCSVimp[0])*TileWts)/TWgen)
                        Tiles_mapGenH=int((len(ListCSVimp)*TileHts)/THgen)
                        nbrTiles_gen=Tiles_mapGenH*Tiles_mapGenW
                        lenW_mapGen=Tiles_mapGenW*TWgen
                        lenH_mapGen=Tiles_mapGenH*THgen
 
                        print 'Tiles_mapGenW,Tiles_mapGenH : '+str(Tiles_mapGenW)+' , '+str(Tiles_mapGenH)
                        print 'nbrTiles_gen : '+str(nbrTiles_gen)
                        print 'lenW_mapGen,lenH_mapGen : '+str(lenW_mapGen)+' , '+str(lenH_mapGen)
                        print'-----------------------'
                        print''
 
                        #liste de sortie
                        list_Tgen=[]#liste des tiles genere
                        list_CSVgen = Tiles_mapGenH*[0]#liste du CSV genere
                        for indexCSV in range(len(list_CSVgen)):#initialisation de la list CSVgen
                                list_CSVgen[indexCSV] = Tiles_mapGenW*[0]
 
                        list_TBuffer=[]#liste des tiles du buffer
 
                        #buffer
                        tilesBuffW=int(TileWgen/TileWts)+2#nombre de tile sur le buffer en x,y
                        tilesBuffH=int(TileHgen/TileHts)+2
 
                        if(tilesBuffW >Tiles_CSVimpW):
                                tilesBuffW=Tiles_CSVimpW
 
                        if(tilesBuffH >Tiles_CSVimpH):
                                tilesBuffH=Tiles_CSVimpH
 
                        print 'tilesBuffW, tilesBuffH apres ajustement : '+str(tilesBuffW)+' , '+str(tilesBuffH)
 
                        lenW_buffer=tilesBuffW*TileWts
                        lenH_buffer=tilesBuffH*TileHts
                        nbrTilesBuf=tilesBuffW*tilesBuffH
 
                        buffer = numpy.empty((lenH_buffer, lenW_buffer) + ListTset[0].shape[2:])
 
                        print 'lenW_buffer, lenH_buffer : '+str(lenW_buffer)+' , '+str(lenH_buffer)
                        print 'nbrTilesBuf : '+str(nbrTilesBuf)
                        print 'buffer size : '+str(buffer.shape)
 
                        #creation des tiles pourle buffer avec la classe TileBuffer
                        for i in range(nbrTilesBuf):
 
                                numTbuffX=int((i%tilesBuffW))#positon de base qu'on aditionne a celle de la tile haut gauchedu buffer
                                numTbuffY=int((i/tilesBuffW))
 
                                posX=numTbuffX*TileWts#position dans le buffer (on ne le calcule u'ne fois)
                                posY=numTbuffY*TileHts
 
                                list_TBuffer.append(TileBuffer(numTbuffX, numTbuffY, posX, posY))
 
                        tilegenCibleX,tilegenCibleY=0,0#ne sert que pour initialiser le buffer au debut sera enlever par la suite
                        old_tileHG_x, old_tileHG_y=0,0
 
                        #percent=0
                        #tilePercent=int(100/nbrTiles_gen)
 
                        #on genere une fois le buffer avant de commencer, commençant a zero le premier utilise le buffer
                        #a mettre en fonction drawBuffer()
 
                        #tuile en haut/gauche du buffer
                        tileHG_x=int((tilegenCibleX*TileWgen)/TileWts)#1er tuile en haut a gauche
                        tileHG_y=int((tilegenCibleY*TileHgen)/TileHts)
 
                        for idxT in list_TBuffer:
 
                                tabTilex=idxT.TileX+tileHG_x
                                tabTiley=idxT.TileY+tileHG_y
 
                                numTile=ListCSVimp[tabTiley][tabTilex]
 
 
                                buffer[idxT.posY : idxT.posY+TileHts , idxT.posX : idxT.posX+TileWts]=ListTset[int(numTile)]
 
 
 
                        print'-------------boucle lance-----------------------'
                        print'------------------------------------------------'
 
                        for cibleY in range(Tiles_mapGenH):
                                for cibleX in range(Tiles_mapGenW):
 
                                        #tile a extraire
                                        temprefX=cibleX
                                        temprefY=cibleY
 
                                        #tileHG dans le buffer
                                        tileHG_x=int((temprefX*TileWgen)/TileWts)
                                        tileHG_y=int((temprefY*TileHgen)/TileHts)
 
                                        #le buffer depasse il de la map?
                                        if tileHG_x > Tiles_CSVimpW-tilesBuffW:
                                                tileHG_x=Tiles_CSVimpW-tilesBuffW
 
                                        if tileHG_y > Tiles_CSVimpH-tilesBuffH:
                                                tileHG_y=Tiles_CSVimpH-tilesBuffH
 
                                        #le buffer doit il est rafraichie
                                        #si le buffer est different on le rafraichie
                                        if(tileHG_x !=old_tileHG_x  or tileHG_y !=old_tileHG_y):
 
                                                old_tileHG_x, old_tileHG_y= tileHG_x, tileHG_y
 
                                                buffer = numpy.empty((lenH_buffer, lenW_buffer) + ListTset[0].shape[2:])
 
                                                for Tib in list_TBuffer:
 
                                                        #numero du graphique a placer
                                                        tabTilex=Tib.TileX+tileHG_x
                                                        tabTiley=Tib.TileY+tileHG_y
 
                                                        numTile=ListCSVimp[tabTiley][tabTilex]
 
                                                        buffer[Tib.posY : Tib.posY+TileHts, Tib.posX : Tib.posX+TileWts]=ListTset[int(numTile)]
 
                                        Tx= (temprefX*TileWgen)-(tileHG_x*TileWts)
                                        Ty= (temprefY*TileHgen)-(tileHG_y*TileHts)
 
                                        TileEnCours=buffer[Ty:(Ty+TileHgen), Tx:(Tx+TileWgen)]
 
                                        for idxgen in range(len(list_Tgen)):
                                                #si la tile existe deja on la note dans le CSVgen
                                                result=numpy.array_equal(TileEnCours,list_Tgen[idxgen])
                                                if(result==True):
 
                                                        list_CSVgen[cibleY][cibleX]=idxgen
                                                        break
                                        else:
                                                #inon on l'ajout a la liste list_Tgen
                                                list_Tgen.append(TileEnCours)
                                                list_CSVgen[cibleY][cibleX]=len(list_Tgen)-1
 
 
                                        #percent+=tilePercent
 
                        #percent=100
                        #print'bouclage tilegen termine'
 
                        self.list_importTileSet=list_Tgen#l'import n'est pasle bonne endroit ou le mettre car deja occupé au
                        #momment de l'import
                        self.list_importCSV=list_CSVgen
 
                else:
                        print'on passe directement les les dossier tileset et CSV'
 
        #self.list_importTileSet=list_Tgen
        #self.list_importCSV=list_CSVgen

NB:dans l'editeur un clic gauche sur une tile designe une tuile a deplacer un deuxieme sr une autre ou l'on veut la pcer. La sauvegarde et l'utilisation du clic droit de la souris n'a pas encore été implémenté.

Bonne journée,

[pierre-y]

Excusez moi, en fait il n'y a pas d'erreur -__-, j'avais juste crue que plateau tournait avec des tiles en 8*8 alors que c'était des 16*16 forcement au découpage ça a fait un caca nerveux.

Je pense mettre se logiciel a disposition quand il sera terminé même si ça ne va pas intéressé grand monde je pense. Par contre si vous pouvez me donner un avis sur comment améliorer la propreté du code je suis preneur.

Avec mes excuse encore et bonne soirée,

[Drawingrom]

Envoyé par pierre-y

Par contre si vous pouvez me donner un avis sur comment améliorer la propreté du code je suis preneur.

OK.

1. Votre méthode parse_CSV est très longue et a visiblement beaucoup de responsabilités : vous devriez la décomposer en plusieurs méthodes.
2. Attention aux conventions sur les noms de variables. Les variables devraient être en snake case (ex: ma_variable) et ne pas commencer par une majuscule (c'est réservé aux définition de classes).
3. Entourez vos opérateurs par des espaces, c'est plus lisible (excepté pour les paramètre nommés dans vos prototypes et appels de méthodes).
4. Utilisez les fonctions de formatage pour vos strings (str.format ou opérateur %). C'est plus élégant que des

Code :

print 'lenW_mapGen,lenH_mapGen : '+str(lenW_mapGen)+' , '+str(lenH_mapGen)

5. Vous faites beaucoup de sorties console pour le debug, peut-être devriez-vous utiliser le module logging.

Concernant la propreté du code et le respect des conventions, vous pouvez utiliser pylint.

[pierre-y]

A merci, je vais regarder tout ça et essayer d'améliorer le code dans se sens.

Par contre pour le conseil ci-dessous, je vois pas du tout ce que c'est. Vous auriez un exemple?

4. Utilisez les fonctions de formatage pour vos strings (str.format ou opérateur %)

[Drawingrom]

Yes : vers la doc officielle http://docs.python.org/2/library/std...string-methods