un return de none type ?

Le problème exposé dans ce sujet a été résolu.

hello le monde ! toujours dans mon projet urworld, apres une modif dans mon code (demandez pas laquelle :D ), j'ai un return de none type qui se fait ! le code qui récupère le return :

1
2
3
perso_retour = deplacer('droite', x_perso, y_perso, structure_niveau, fov)
if perso_retour[1] == "liste":
    # then do ...

et le code faisant le return :

1
2
3
4
5
6
7
8
9
elif structure[case_y + 1][case_x + 1] in bloc_tombe:
    print('IN')
    liste_pos_tombe = []
    cpt_tombe = 1
    while structure[case_y + cpt_tombe][case_x + 1] in bloc_tombe:
         #on tombe et on ajoute les positions dans la liste a renvoyer
         liste_pos_tombe += [((case_x + 1) * taille_sprite, case_y * taille_sprite + 30 * cpt_tombe)]
         cpt_tombe += 1
    return [liste_pos_tombe, 'liste']

mais le problème est que : je ne rentre jamais dans ce elif ! j'ai mis print ('in') pour savoir si j'allais dedans … mais non ! et pourtant j'ai bien un else:

1
2
else:
    return [(dernier_x, case_y * taille_sprite), '']

que faire ? merci à vous, folaefolc

+0 -0

la fonction complete de déplacement sans déplacement du fov :

  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
def deplacer(direction, x_perso, y_perso, structure, fov):
    #liste des blocs :
    liste_bloc = [
    'p', 'e', 'a', 'm', 't', 'c',
    '1', '2', '3', '4', '5', '6',
    '7', '8', 'r', 'y', 'u', 'i',
    'M', 'x', 'b', 'n', '?', '.',
    '/', "A", "Z", "E", "R", "T",
    "Y", "U", "I", 's', 'O', 'h']

    bloc_tombe = [
    'd', 'q', '0', 'v', 'l', 'k',
    'g', 'f', 'P']


    liste_pos_tombe = []
    dernier_x = x_perso
    dernier_y = y_perso
    case_x = x_perso // 30 + fov[0]
    case_y = y_perso // 30
    cpt_tombe = 1
    #Déplacement vers la droite
    if direction == 'droite':
        #Pour ne pas dépasser l'écran
        if case_x <= (nombre_sprite_cote - 1) and case_x + 1 <= (nombre_sprite_cote - 1):
            try:
                #On vérifie que la case de destination n'est pas un mur
                if (structure[case_y + 1][case_x + 1] in bloc_tombe) \
                        and structure[case_y][case_x + 1] not in liste_bloc \
                        and case_y + 2 <= 20:
                    if structure[case_y + 2][case_x + 1] in liste_bloc:
                        #c'est 'un escalier' !
                        return [((case_x + 1) * taille_sprite, (case_y + 1) * taille_sprite), '']
                elif structure[case_y][case_x + 1] not in liste_bloc and structure[case_y + 1][
                            case_x + 1] not in bloc_tombe:
                    #Déplacement d'une case
                    #Calcul de la position "réelle" en pixel
                    return [((case_x + 1) * taille_sprite, case_y * taille_sprite), '']
                elif structure[case_y][case_x + 1] in liste_bloc \
                        and (structure[case_y - 1][case_x + 1] in bloc_tombe) \
                        and structure[case_y - 1][case_x] not in liste_bloc \
                        and structure[case_y][case_x + 1] in liste_bloc:
                    #c'est 'un escalier' !
                    return [((case_x + 1) * taille_sprite, (case_y - 1) * taille_sprite), '']
                elif structure[case_y + 1][case_x + 1] in bloc_tombe:
                    print('IN')
                    liste_pos_tombe = []
                    cpt_tombe = 1
                    while structure[case_y + cpt_tombe][case_x + 1] in bloc_tombe:
                        #on tombe et on ajoute les positions dans la liste a renvoyer
                        liste_pos_tombe += [((case_x + 1) * taille_sprite, case_y * taille_sprite + 30 * cpt_tombe)]
                        cpt_tombe += 1
                        if structure[case_y + cpt_tombe][case_x + 1] not in bloc_tombe:
                            return [liste_pos_tombe, 'liste']
                else:
                    return [(dernier_x, case_y * taille_sprite), '']
            except IndexError:
                return [(dernier_x, case_y * taille_sprite), '']
                pass
            except TypeError:
                return [(dernier_x, case_y * taille_sprite), '']
                pass
            except ValueError:
                return [(dernier_x, case_y * taille_sprite), '']
                pass
            except Exception:
                return [(dernier_x, case_y * taille_sprite), '']
        else:
            return [(dernier_x, case_y * taille_sprite), '']
    #Déplacement vers la gauche
    if direction == 'gauche':
        if case_x >= 0 and case_x - 1 >= 0:
            try:
                if (structure[case_y + 1][case_x - 1] in bloc_tombe) \
                        and structure[case_y][case_x - 1] not in liste_bloc \
                        and case_y + 2 <= 20:
                    if structure[case_y + 2][case_x - 1] in liste_bloc:
                        #c'est 'un escalier' !
                        return [((case_x - 1) * taille_sprite, (case_y + 1) * taille_sprite), '']
                elif structure[case_y][case_x - 1] not in liste_bloc and structure[case_y + 1][
                            case_x - 1] not in bloc_tombe:
                    return [((case_x - 1) * taille_sprite, case_y * taille_sprite), '']
                elif structure[case_y][case_x - 1] in liste_bloc \
                        and (structure[case_y - 1][case_x - 1] in bloc_tombe) \
                        and structure[case_y - 1][case_x] not in liste_bloc:
                    #c'est 'un escalier' !
                    return [((case_x - 1) * taille_sprite, (case_y - 1) * taille_sprite), '']
                elif structure[case_y + 1][case_x - 1] in bloc_tombe:
                    liste_pos_tombe = []
                    cpt_tombe = 1
                    while structure[case_y + cpt_tombe][case_x - 1] in bloc_tombe:
                        #on tombe et on ajoute les positions dans la liste a renvoyer
                        liste_pos_tombe += [((case_x - 1) * taille_sprite, case_y * taille_sprite + 30 * cpt_tombe)]
                        cpt_tombe += 1
                    return [liste_pos_tombe, 'liste']
                else:
                    return [(dernier_x, case_y * taille_sprite), '']
            except IndexError:
                return [(dernier_x, case_y * taille_sprite), '']
                pass
            except TypeError:
                return [(dernier_x, case_y * taille_sprite), '']
                pass
            except ValueError:
                return [(dernier_x, case_y * taille_sprite), '']
                pass
        else:
            return [(dernier_x, case_y * taille_sprite), '']
    #Déplacement vers le haut
    if direction == 'haut':
        if case_y > 0 and case_y - 1 > 0:
            if structure[case_y - 1][case_x] not in liste_bloc:
                y_perso = (case_y - 1) * taille_sprite
                return [(case_x * taille_sprite, y_perso), '']
            else:
                return [(case_x * taille_sprite, dernier_y), '']
        else:
            return [(case_x * taille_sprite, dernier_y), '']
    #Déplacement vers le bas
    if direction == 'bas':
        if case_y < (nombre_sprite_cote - 1) and case_y + 1 < (nombre_sprite_cote - 1):
            if structure[case_y + 1][case_x] not in liste_bloc:
                y_perso = (case_y + 1) * taille_sprite
                return [(case_x * taille_sprite, y_perso), '']
            else:
                return [(case_x * taille_sprite, dernier_y), '']
        else:
            return [(case_x * taille_sprite, dernier_y), '']
+0 -0

Il y a des problèmes de conception… une fonction bien trop longue et aussi des lignes choquantes comme celles allant de ligne 97 à 108 par exemple.

ligne 23, on voit que ça part mal, on pourrait très bien travailler avec des Constantes/entiers

1
2
3
4
DROITE = (1, 0)
GAUCHE = (-1, 0)
HAUT = (0, 1)
BAS = (0, -1)

On peut aussi facilement travailler avec les diagonales…

+1 -0

De manière générale, il faut éviter les fonctions de plus de 30 lignes => ça veut sûrement dire que tu aurais pu créer plusieurs fonctions de moindre taille :

  • meilleure lisibilité

  • debug plus facile

Juste un conseil :)

+0 -0

Bah y'a une regle d'or encore plus simple : si tu t'apprêtes à copier-coller un bout de code c'est que tu as un problème de factorisation. Typiquement, là, on a un code qui se répète quasiment à l'identique pour chaque direction.

+0 -0

Bah, il suffit de remarquer que le code a exactement la même structure, donc que tu peux l'abstraire. Les seuls trucs qui changent c'est les +1 ou -1 en fonction du mouvement du joueur : il suffit de les placer dans deux variables dx et dy.

D'après ce que je lis de ton code, ça donne un truc comme ça :

1
2
3
4
5
6
7
8
mouvement = {
    'droite': (+1, +1),
    'gauche': (-1, +1),
    'haut': (0, -1),
    'bas': (0, +1)
}

dx, dy = mouvement[direction]

Et maintenant, c'est parti pour la refacto. Le premier if que tu fais sert à vérifier que le mouvement ne fait pas sortir le joueur du plateau : 

1
2
3
4
5
xmax = ymax = nombre_sprite_cote
mvt_x, mvt_y = case_x + dx, case_y + dy
if 0 <= mvt_x < xmax and 0 <= mvt_y < ymax: 
    try:
        # reste de ton code...

Voilà, tu n'as plus qu'à refaire tes if/else en fonction des variables définies ci-dessus, et tu diviseras déjà par 4 la taille de ta fonction.

+2 -0
Connectez-vous pour pouvoir poster un message.
Connexion

Pas encore membre ?

Créez un compte en une minute pour profiter pleinement de toutes les fonctionnalités de Zeste de Savoir. Ici, tout est gratuit et sans publicité.
Créer un compte