Discussion :

[LittleWhite]

Par exemple : http://1fichier.com/

[antho_rafa501]

Bonjour à tous ,

Désoler de ne pas avoir donné encore de nouvelle mais
je travaille en ce moment avec mes parents ,

Bon voilà j'ai modifier plusieurs fonction pour qu'il ne fasse que 70 lignes
et je suis en train de d'introduire la fonction va chargé les niveaux .

Installation automatique
Ressources
Sources

[LittleWhite]

Les fonctions dans mouvement_serpent.c peuvent être encore simplifiées. On doit arriver à faire qu'une seule fois ce switch (direction_joueyr) et appeler la fonction qui fera toutes les actions en conséquence. Et même, si on se débrouille bien, cette fonction pourra être utilisée pour les quatre directions.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
    // si la direction est vers la droite 
    case D_DROITE: 
        gSerpent->positionTete.x = gSerpent->positionXY.x * TAILLE_BLOC; 
        break; 
    // si la direction est vers la gauche 
    case D_GAUCHE: 
        gSerpent->positionTete.x = gSerpent->positionXY.x * TAILLE_BLOC; 
        break; 
    // si la direction est vers le haut 
    case D_HAUT: 
        gSerpent->positionTete.y = gSerpent->positionXY.y * TAILLE_BLOC; 
        break; 
    // si la direction est vers le bas 
    case D_BAS: 
        gSerpent->positionTete.y = gSerpent->positionXY.y * TAILLE_BLOC; 
        break;

Je me demande s'il n'y a pas une erreur (car, vous faites les mêmes choses dans deux cas). Mais si vous êtes sur de votre code, vous pouvez simplifier de la sorte:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
    // si la direction est vers la droite 
    case D_DROITE: 
    case D_GAUCHE: 
        gSerpent->positionTete.x = gSerpent->positionXY.x * TAILLE_BLOC; 
        break; 
    // si la direction est vers le haut 
    case D_HAUT: 
    case D_BAS: 
        gSerpent->positionTete.y = gSerpent->positionXY.y * TAILLE_BLOC; 
        break;

La fonction directionEnString() du fichier jeu.c est dangereuse :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
/* Cette fonction va me servire à convertir la direction du joueurs en char*/ 
void directionEnString(Serpent gSerpent, char *directionEnCaractere) 
{ 
    if(gSerpent.direction_joueur == D_DROITE) // si la direction est droite 
    { 
        sprintf(directionEnCaractere,"DROITE"); 
    } 
    else if(gSerpent.direction_joueur == D_GAUCHE) // si la direction est gauche 
    { 
        sprintf(directionEnCaractere,"GAUCHE"); 
    } 
    else if(gSerpent.direction_joueur == D_HAUT) 
    { 
        sprintf(directionEnCaractere,"HAUT"); // si la direction est haut 
    } 
    else if(gSerpent.direction_joueur == D_BAS) // si la direction est bas 
    { 
        sprintf(directionEnCaractere,"BAS"); 
    } 
 
}

Il faut être sur que la taille du tableau soit suffisante pour accepter les caractères. Du coup, il faudrait que l'allocation du tableau soit à l'intérieur de la fonction (comme ça, nous sommes sur de sa taille). Le seul problème, c'est que du coup, il faut renvoyer un pointeur et ce pointeur devra être libéré en dehors de la fonction (ce qui peut être facilement oublié, donc fuite de mémoire).
Du coup, comme solution, je proposerai d'utiliser des const char* qui serai déclaré static et simplement retourné selon les cas.

Dans jeu.c :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
// pour la consommation dans la ram n'augmente pas ! 
    SDL_FreeSurface(gImage->texte_score);

Dans une fonction d'affichage, ce genre de truc est horrible. En plus, avec le commentaire, qui semble dire: "Je corrige une fuite de mémoire" ... mais vous le faites un peu n'importe comment.

Finalement, le fichier chargement_sprite propose une fonction de chargement, mais du coup, je me demande où est la fonction de libération. Du coup, j'aurais tendance à renommer le fichier en ressources_sprite qui se composerait du chargement et de la libération.

[antho_rafa501]

Bonsoir, dans le fichier mouvement_serpent.c ces instruction n'existe pas dans mes fichier , ce serais bien si tu pouvais me dire la ligne de code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
    // si la direction est vers la droite 
    case D_DROITE: 
        gSerpent->positionTete.x = gSerpent->positionXY.x * TAILLE_BLOC; 
        break; 
    // si la direction est vers la gauche 
    case D_GAUCHE: 
        gSerpent->positionTete.x = gSerpent->positionXY.x * TAILLE_BLOC; 
        break; 
    // si la direction est vers le haut 
    case D_HAUT: 
        gSerpent->positionTete.y = gSerpent->positionXY.y * TAILLE_BLOC; 
        break; 
    // si la direction est vers le bas 
    case D_BAS: 
        gSerpent->positionTete.y = gSerpent->positionXY.y * TAILLE_BLOC; 
        break;

et

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
    // si la direction est vers la droite 
    case D_DROITE: 
    case D_GAUCHE: 
        gSerpent->positionTete.x = gSerpent->positionXY.x * TAILLE_BLOC; 
        break; 
    // si la direction est vers le haut 
    case D_HAUT: 
    case D_BAS: 
        gSerpent->positionTete.y = gSerpent->positionXY.y * TAILLE_BLOC; 
        break;

Ce que je voudrais dire c'est que je ne peux pas le simplifier plus aussi.
Et aussi pour

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

SDL_FreeSurface(gImage->texte_score);

je n'avais pas d'autre choix car sinon la consommation en mémoire dans le gestionnaire de tâche me dit que il augment chaque seconde.

Finalement pour

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
/* Cette fonction va me servire à convertir la direction du joueurs en char*/ 
void directionEnString(Serpent gSerpent, char *directionEnCaractere) 
{ 
    if(gSerpent.direction_joueur == D_DROITE) // si la direction est droite 
    { 
        sprintf(directionEnCaractere,"DROITE"); 
    } 
    else if(gSerpent.direction_joueur == D_GAUCHE) // si la direction est gauche 
    { 
        sprintf(directionEnCaractere,"GAUCHE"); 
    } 
    else if(gSerpent.direction_joueur == D_HAUT) 
    { 
        sprintf(directionEnCaractere,"HAUT"); // si la direction est haut 
    } 
    else if(gSerpent.direction_joueur == D_BAS) // si la direction est bas 
    { 
        sprintf(directionEnCaractere,"BAS"); 
    } 
 
}

j'ai remplacé par ceci

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
/* Cette fonction va me servire à convertir la direction du joueurs en char*/
const char* directionEnString(Serpent gSerpent)
{
    static const char *droite = "DROITE";
    static const char *gauche = "GAUCHE";
    static const char *bas = "BAS";
    static const char *haut = "HAUT";
 
    if(gSerpent.direction_joueur == D_DROITE) // si la direction est droite
    {
        return droite; //sprintf(directionEnCaractere,"DROITE");
    }
    else if(gSerpent.direction_joueur == D_GAUCHE) // si la direction est gauche
    {
        return gauche;     //sprintf(directionEnCaractere,"GAUCHE");
    }
    else if(gSerpent.direction_joueur == D_HAUT)
    {
        return haut;
        //sprintf(directionEnCaractere,"HAUT"); // si la direction est haut
    }
    else if(gSerpent.direction_joueur == D_BAS) // si la direction est bas
    {
        return bas;
        //sprintf(directionEnCaractere,"BAS");
    }
    return;
 
};

[LittleWhite]

Le bloc a simplifier est dans la fonction : void miseAjoursPositionTete(Serpent *gSerpent)
La simplification globale (car on trouve 5 fois le test : switch(gSerpent->direction_joueur) consiste à faire en sorte que ce test soit unique et que les actions qui sont nécessaires de faire à chaque fois, soit dans une fonctions, par exemple.

Finalement, votre nouvelle fonction const char* directionEnString(Serpent gSerpent) peut utiliser un switch()/case à la place des if / else.

[antho_rafa501]

Voilà la fonction short miseAjoursPositionTete est modifier maintenant il est comme ça

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
short miseAjoursPositionTete(int carte_[][NB_BLOCS_LARGEUR], Serpent *gSerpent, int fonction )
{
    // -------------------------------------------
    // on fonction de la direction du joueur met à jours
    // la position de la Tete
    // -------------------------------------------
    switch(gSerpent->direction_joueur)
    {
    // si la direction est vers la droite
    case D_DROITE:
        switch(fonction)
        {
            case -1:
                break;
            case MANGE_CERISE:
                gSerpent->positionXY.x = gSerpent->positionXY.x + 1;
                break;
            case FONCTIONAUTRECOTER:
                if( gSerpent->positionListCorpsXY[0].x == gSerpent->positionXY.x+1)
                    return BLOCAGE;
                break;
            case VERIFICATIONAUTREBOUTDELACARTE:
                if( gSerpent->positionXY.x == NB_BLOCS_LARGEUR-1 && carte_[gSerpent->positionXY.y][0] != MUR)
                {
                    gSerpent->positionXY.x = 0;
                    return 1;
                }
                break;
            case DEPLACEMENTETE:
                gSerpent->positionXY.x = gSerpent->positionXY.x + 1;
                break;
 
        }
        gSerpent->positionTete.x = gSerpent->positionXY.x * TAILLE_BLOC;
        break;
    // si la direction est vers la gauche
    case D_GAUCHE:
        switch(fonction)
        {
            case -1:
                break;
            case MANGE_CERISE:
                gSerpent->positionXY.x = gSerpent->positionXY.x - 1;
                break;
            case FONCTIONAUTRECOTER:
                if ( gSerpent->positionListCorpsXY[0].x == gSerpent->positionXY.x-1 )
                return BLOCAGE;
                break;
            case VERIFICATIONAUTREBOUTDELACARTE:
                if( gSerpent->positionXY.x == 0 && carte_[gSerpent->positionXY.y][NB_BLOCS_LARGEUR-1] != MUR)
                {
                    gSerpent->positionXY.x = NB_BLOCS_LARGEUR-1;
                    return 1;
                }
                break;
            case DEPLACEMENTETE:
                gSerpent->positionXY.x = gSerpent->positionXY.x - 1;
                break;
        }
        gSerpent->positionTete.x = gSerpent->positionXY.x * TAILLE_BLOC;
        break;
    // si la direction est vers le haut
    case D_HAUT:
        switch(fonction)
        {
            case -1:
                break;
            case MANGE_CERISE:
                gSerpent->positionXY.y = gSerpent->positionXY.y - 1;
                break;
            case FONCTIONAUTRECOTER:
                if( gSerpent->positionListCorpsXY[0].y == gSerpent->positionXY.y-1)
                    return BLOCAGE;
                break;
            case VERIFICATIONAUTREBOUTDELACARTE:
                if( gSerpent->positionXY.y == 0 && carte_[gSerpent->positionXY.y][NB_BLOCS_LARGEUR-1] != MUR)
                {
                    gSerpent->positionXY.y = NB_BLOCS_HAUTEUR-1;
                    return 1;
                }
                break;
            case DEPLACEMENTETE:
                gSerpent->positionXY.y = gSerpent->positionXY.y - 1;
                break;
        }
        gSerpent->positionTete.y = gSerpent->positionXY.y * TAILLE_BLOC;
        break;
    // si la direction est vers le bas
    case D_BAS:
        switch(fonction)
        {
            case -1:
                break;
            case MANGE_CERISE:
                gSerpent->positionXY.y = gSerpent->positionXY.y + 1;
                break;
            case FONCTIONAUTRECOTER:
                if( gSerpent->positionListCorpsXY[0].y == gSerpent->positionXY.y+1)
                    return BLOCAGE;
                break;
            case VERIFICATIONAUTREBOUTDELACARTE:
                if( gSerpent->positionXY.y == NB_BLOCS_HAUTEUR-1 && carte_[0][gSerpent->positionXY.x] != MUR)
                {
                    gSerpent->positionXY.y = 0;
                    return 1;
                }
                break;
            case DEPLACEMENTETE:
                gSerpent->positionXY.y = gSerpent->positionXY.y + 1;
                break;
        }
        gSerpent->positionTete.y = gSerpent->positionXY.y * TAILLE_BLOC;
        break;
    // la direction n'existe pas!
    default:
        break;
    }
 
}

C'est comme ça que vous voulez dire ?

[antho_rafa501]

Bonjour à tous,

Voilà déjà plusieurs jour que je n'ai pas donné de nouvelle voilà
les le sources pour l'éditeur de map . Il n'est pas encore fini

-> http://lubkdb.1fichier.com/

[antho_rafa501]

Bonjours à tous,

J'ai fais plein de modification dans mes codes sources .
L'éditeur de niveau presque fini car il faudrait que je puisse
gérer plusieurs niveau à la fois . Quand vous êtes en mode éditeur
vous pouvez modifier le nombre de blocs en X et Y aussi pour
cela il suffit de faire un clique gauche sur le chiffre puis de faire BACKSPACE pour revenir en arrière le "curseur" et depuis le pavé numérique de choisir les chiffres que vous voulez l'attribuée .
Pour validé il suffit de faire un clique droite!

Bon si vous avez des bonnes ou mauvais avis faites moi savoir .

Sources : Jeux serpent sources r5
Ressources : Ressources r5

A bientôt

[LittleWhite]

En théorie, le main.c ne devrait que contenir la fonction main.

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

short miseAjoursPositionTete(Carte *pCarte, Serpent *gSerpent, int fonction )

Je trouve cette fonction trop longue, mais je ne sais pas la factoriser.
Ou alors, il faut faire un switch(fonction) et ensuite vous appeler une sous fonction correspondante, qui contient le switch de la direciton. Et cela pour chaque "fonction".

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

void supp_image_editeur(Gestion_image *gImage, Texte_Editeur *gTexte)

Cette fonction aurait du être le parfait miroir de la fonction chargement. Mais étrangement, vous avez rajouté la partie de la libération du texte dans celle ci.

Vous devriez mettre les structures dans les fichiers appropriés (là où la structure est nécessaire et où cela semble le plus correct).

Vous avez refait des fonctions d'affichage pour l'éditeur. Êtes vous sur que vous ne pouviez pas afficher la fonction préexistante et utilisée pour le jeu ? D'autant plus, cette question trouvera sa réponse, si vous avez fait un copier coller lors de la création de cette fonction.

Les fonctions de l'éditeur sont trop grosses

Chaque fonction acceptant un pointeur devrait avoir un assert() associé à ce pointer -> http://alexandre-laurent.developpez....ications/#L3-A

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
while(SDL_PollEvent(&event))
        {
            switch(event.type)
            {
            case SDL_QUIT:
                continuer = 0;
                break;
 
            case SDL_KEYDOWN: // pour la gestion des touches du clavier
                gestion_touche(event, &gSerpent, &continuer, ecran);
                break;
            }
        }

Je pense avoir vu ce morceau de code plusieurs fois. Donc je pense pouvoir affirmer qu'il est factorisable.

Sinon, il ne devrait avoir qu'un seul endroit où les évènements sont gérés.

[antho_rafa501]

Bonjour / Bonsoir à vous voilà depuis un bon moment que je n'ai pas donné de mes nouvelles .

Je sort de l'hôpital depuis 4 jours et je me rétablie petit à petit .
Quand j'aurais fini les modification que tu m'a donné de faire
je le posterais directement sur le forum le plus rapidement possible mais pour l'instant le plus important c'est la santé.

Donc à bientôt

[antho_rafa501]

Bonjours / bonsoir à tous

Bon je viens de mettre à jour le mini jeu.

Si vous voulez des explication il faut partir voir le README

Voilà le lien -> Jeux serpent source R7

Bon test à vous.

[LittleWhite]

Je trouve que les fonctions gestion_event() / affichage_ecran_editeur prennent trop d'arguments, donc je conseille d'utiliser une structure qui regroupe le tout.

Je crois que l'organisation du code est un peu ... comme un bazar. Dans le sens, je trouve tout plein d'endroit où il y a des fonctions de dessin. Qui je crois, pour certaines recopie le même code. On pourrait alors imaginer une fonction simple, qui englobe l'appel de la fonction SDL (la simplifie au passage) et fait en sorte que tout cela soit plus facile à utiliser.

Le but est de factorisé le code. D'autres fonctions, petites fonctions, qui prépare les choses, permettent aussi de restructurer le code et de le simplifier.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 else if( in.mousex >= 483 && in.mousey >= 325 &&
             in.mousex <= 632 && in.mousey <= 414 &&
             in.mousebuttons[SDL_BUTTON_LEFT] )
    {
        sprintf(zone_niveau, "Difficile");
        *niveau = DIFFICILE;
        couleur->r = 255;
        couleur->g = 255;
        couleur->b = 255; // le couleur du texte est noir
    }
    else if( (in.mousey < 325 && in.mousebuttons[SDL_BUTTON_LEFT]) ||
             (in.mousey > 414 && in.mousebuttons[SDL_BUTTON_LEFT]) ||
             (in.mousex < 45  && in.mousebuttons[SDL_BUTTON_LEFT]) ||
             (in.mousex > 632 && in.mousebuttons[SDL_BUTTON_LEFT]) ||
             (in.mousex > 183 && in.mousex < 264 && in.mousebuttons[SDL_BUTTON_LEFT]) ||
             (in.mousex > 404 && in.mousex < 483 && in.mousebuttons[SDL_BUTTON_LEFT]) )
    {
        sprintf(zone_niveau, "AUCUN NIVEAU");
        *niveau = AUCUN_NIVEAU;
        couleur->r = 0;
        couleur->g = 0;
        couleur->b = 0;
    }

Les coordonnées sont écrites en dur. Peut être que l'on peut faire mieux, tout de même, afin de permettre facilement de changer l'image (ou la forme).

Il semble aussi qu'il manque toujours les tests pour savoir si les fichiers sont bien chargés (ressources_sprites.c)

[antho_rafa501]

Salut,

Merci pour beaucoup pour les réponses !
Je crois que maintenant je vais pouvoir plus l'améliorer .
Je posterais quand j'aurais fait les modification.

A bientôt.

[antho_rafa501]

Bonjour/Bonsoir à tous!

Voilà je vais reprendre les études et réapprendre tout ce que je doit savoir.
Donc je voudrais vous dire que pour le moment le projet est en pause.

A bientôt!