Publicité
+ Répondre à la discussion
Affichage des résultats 1 à 5 sur 5
  1. #1
    Membre régulier
    Inscrit en
    décembre 2007
    Messages
    107
    Détails du profil
    Informations forums :
    Inscription : décembre 2007
    Messages : 107
    Points : 70
    Points
    70

    Par défaut demande de conseille pour un probleme sur une fonction

    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,
    Fichiers attachés Fichiers attachés

  2. #2
    Membre régulier
    Inscrit en
    décembre 2007
    Messages
    107
    Détails du profil
    Informations forums :
    Inscription : décembre 2007
    Messages : 107
    Points : 70
    Points
    70

    Par défaut

    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,

  3. #3
    Membre éclairé
    Inscrit en
    mai 2006
    Messages
    285
    Détails du profil
    Informations forums :
    Inscription : mai 2006
    Messages : 285
    Points : 394
    Points
    394

    Par défaut

    Citation Envoyé par pierre-y Voir le message
    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.

  4. #4
    Membre régulier
    Inscrit en
    décembre 2007
    Messages
    107
    Détails du profil
    Informations forums :
    Inscription : décembre 2007
    Messages : 107
    Points : 70
    Points
    70

    Par défaut

    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 %)

  5. #5
    Membre éclairé
    Inscrit en
    mai 2006
    Messages
    285
    Détails du profil
    Informations forums :
    Inscription : mai 2006
    Messages : 285
    Points : 394
    Points
    394

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

Liens sociaux

Règles de messages

  • Vous ne pouvez pas créer de nouvelles discussions
  • Vous ne pouvez pas envoyer des réponses
  • Vous ne pouvez pas envoyer des pièces jointes
  • Vous ne pouvez pas modifier vos messages
  •