Lecture d'un fichier

**lapos** · 17/08/2007, 12h58

Bonjour a tous

Voilà, je possède un fichier que j'aimerais lire. Toutes les valeurs de ce fichier doivent rentrer le tableau bidimenseionnel carte.

Tout marchais bien jusqu'a prèsent, mais j'ai remarqué que lorsque je modifiais ma constante NB_BLOCS_HAUTEUR cela bugait

Et je ne comprend pas ou cela peut il bien buggé.

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
void chargerCarte(int carte[][NB_BLOCS_HAUTEUR])
{
  FILE *fichier=fopen("carte.txt","r");
 
  if(fichier!=NULL)
  {
    long y = 0;
    char ligne[NB_BLOCS_LARGEUR + 2] = "";
    while (fgets (ligne,NB_BLOCS_LARGEUR + 2, fichier) != NULL)
      {
         if (y < NB_BLOCS_HAUTEUR)
         {
            int x;
            for (x = 0; x< NB_BLOCS_LARGEUR; x++)
            {
               switch (ligne[x])
               {
               case '0':
                  carte[x][y] = MUR; 
                  break;
               case '1':
                  carte[x][y] = CHEMIN; 
                  break;
 
               default:
                  break;
               }
            }
            y++;
         }
         else
         {
            break;
         }
      }
    fclose(fichier);
  }
}

Merci d'avance.

**Fabllot** · 17/08/2007, 18h20

Bonjour,

Envoyé par lapos

Tout marchais bien jusqu'a prèsent, mais j'ai remarqué que lorsque je modifiais ma constante NB_BLOCS_HAUTEUR cela bugait

C'est-à-dire ? Que ce passe-t-il quand ça "bug" ? Et quels sont tes valeurs pour ta constante NB_BLOCS_HAUTEUR ?

**lapos** · 17/08/2007, 19h47

Alors, lorsque je change la valeur de NB_BLOCS_HAUTEUR, ma carte est "coupée".

Si elle aurait été coupé horizontalement ça aurais été logique, mais c'est verticalement

Habituellement, NB_BLOCS_HAUTEUR et NB_BLOCS_LARGEUR ont la même valeur (80), mais pour raison pratique j'ai modifié NB_BLOCS_HAUTEUR à 48.

Et c'est la que j'ai vu que ça foirait

**Emmanuel Delahaye** · 17/08/2007, 20h16

Envoyé par lapos

Alors, lorsque je change la valeur de NB_BLOCS_HAUTEUR, ma carte est "coupée".

Si elle aurait été coupé horizontalement ça aurais été logique, mais c'est verticalement

Habituellement, NB_BLOCS_HAUTEUR et NB_BLOCS_LARGEUR ont la même valeur (80), mais pour raison pratique j'ai modifié NB_BLOCS_HAUTEUR à 48.

Et c'est la que j'ai vu que ça foirait

Il y a une inversion d'indice quelque part (x à la place de y etc.)

**lapos** · 17/08/2007, 21h34

Je m'en doutait un peu, mais bon, j'ai beau tout regarder je ne vois pas où a bien pû se produire cette $¨!§^%ù d'inversion

Voici les deux fonctions qui manipulent ma carte :

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
#include <SDL/SDL.h>
 
#include "constantes.h"
#include "carte.h"
#include "gestion.h"
 
#define CASES_ECRAN_L 16
#define CASES_ECRAN_H 12
 
void gestionScrolling(Position *position)
{
    int a = position->jx, b = position->jy;
    int starty = b-(CASES_ECRAN_H/2)+1;
    int startx = a-(CASES_ECRAN_L/2)+1;
    int stopx, stopy;
 
    startx = (startx < 0)?0:startx; /*Si startx est plus petit que 0, il est égale a 0*/
    starty = (starty < 0)?0:starty; /*idem*/
 
    stopx = startx + CASES_ECRAN_L;
    stopy = starty + CASES_ECRAN_H;
 
    stopy = (stopy>NB_BLOCS_LARGEUR)?NB_BLOCS_LARGEUR:stopy; /*Si stopy est plus grand que NB_BLOCS_LARGEUR, il est égale a NB_BLOCS_LARGEUR*/
    stopx = (stopx>NB_BLOCS_HAUTEUR)?NB_BLOCS_HAUTEUR:stopx;/*Idem*/
 
 
    /* Mis a jour de la position */
    position->startx = startx;
    position->starty = starty;
    position->stopx = stopx;
    position->stopy = stopy;
}

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
void scrolling(SDL_Surface *ecran,
               int carte[][NB_BLOCS_HAUTEUR],
               Position *position,
               int deplacement)
{
    int y=0,x=0;
    int startx, starty, stopx, stopy;
    SDL_Rect _position;
    SDL_Surface *mur=NULL,*chemin=NULL,*joueur=NULL;
    static int test=RIEN, marqueur=RIEN; /*Static pour permettre de garder en mémoire leur valeur*/
 
    mur=gestion_chercheRessource(MUR); /*Utilisation de gestion_chercheRessource pour ne pas a avoir recharger l'image*/
    chemin=gestion_chercheRessource(CHEMIN);
 
    if(test!=deplacement) /*si le joueur a bougé*/
     {
       switch(deplacement)
       {
         /*Si le joueur a bougé, on donne une valeur à marqueur*/
         case BAS :
              marqueur=BAS;
              break;
 
         case HAUT:
              marqueur=HAUT;
              break;
 
         case DROITE:
              marqueur=DROITE;
              break;
 
         case GAUCHE:
              marqueur=GAUCHE;
              break;
 
         default:
              break;
       }
 
     }
 
     test=deplacement; /*On donne la valeur de déplacement a test pour que test garde en mémoire le dernier déplacement*/
 
     switch(marqueur)
     {
         /*Suivant la valeur de marqueur, on lui donne une image particulière*/
         case RIEN :
              joueur=gestion_chercheRessource(JOUEUR_BAS);
              break;
 
         case BAS :
              joueur=gestion_chercheRessource(JOUEUR_BAS);
              break;
 
         case HAUT:
              joueur=gestion_chercheRessource(JOUEUR_HAUT);
              break;
 
         case DROITE:
              joueur=gestion_chercheRessource(JOUEUR_DROITE);
              break;
 
         case GAUCHE:
              joueur=gestion_chercheRessource(JOUEUR_GAUCHE);
              break;
 
         default:
              break;
 
     }
 
    /* On prend les anciennes valeurs */
    startx = position->startx;
    starty = position->starty;
    stopx = position->stopx;
    stopy = position->stopy;
 
    for(x=startx; x < stopx; x++)
    {
        for(y=starty; y < stopy; y++)
        {
            /*Lorsque x et y sont soustraient par startx et starty puis multipliées
            par TAILLE_BLOC, cela  permet d'indiquer la position des terrains */
            _position.x=(x-startx)*TAILLE_BLOC;
            _position.y=(y-starty)*TAILLE_BLOC;
            switch(carte[x][y])
            {
                /*Blittage du terrain qu'il y a dans carte[x][y]*/
                case CHEMIN:
                    SDL_BlitSurface(chemin,NULL,ecran, &_position);
                    break;
 
                case MUR:
                    SDL_BlitSurface(mur,NULL,ecran, &_position);
                    break;
 
                default:
                    break;
            }
        }
    }
 
    /*Soustraient par startx et starty puis multipliées par TAILLE_BLOC
    infos->jx et infos->jy permettent d'indiquer la position du joueur*/
    _position.x=(position->jx-startx)*TAILLE_BLOC;
    _position.y=(position->jy-starty)*TAILLE_BLOC;
 
   /*Blittage du joueur*/
    SDL_BlitSurface(joueur,NULL,ecran,&_position);
 
}

Et voici mon fichier constantes.h :

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
#ifndef DEF_CONSTANTES
#define DEF_CONSTANTES
 
#define TAILLE_BLOC 70
#define NB_BLOCS_LARGEUR 80
#define NB_BLOCS_HAUTEUR 48
 
enum{RIEN,HAUT,BAS,GAUCHE,DROITE}; /*Sert a situer la direction du joueur */
enum{MUR,CHEMIN,                                                /****************************************************/
          JOUEUR_BAS, JOUEUR_BAS_SEL,                       /*                                                                            */
          JOUEUR_HAUT, JOUEUR_HAUT_SEL,                 /*        Constantes servant a être utiliser par               */
          JOUEUR_GAUCHE, JOUEUR_GAUCHE_SEL,        /*             gestion_chercheRessource  et                     */
          JOUEUR_DROITE, JOUEUR_DROITE_SEL,           /*              gestion_videRessource.                              */
          JOUER,JOUER_SEL,                                        /*                                                                             */
          EDITEUR,EDITEUR_SEL,                                  /*                                                                             */
          QUITTER,QUITTER_SEL,                                  /****************************************************/
          NBR_SURFACE}; /*Placé a la fin pour être sur qu'il y ai assez de place dans le tableau*/
 
typedef struct Position Position;
struct Position
{
    /*position du joueur*/
    int jx;
    int jy;
 
    /*position de l'affichage*/
    int startx;
    int starty;
    int stopx;
    int stopy;
};
#endif

J'espère que vous aller trouver cette inversion car sinon

**Fabllot** · 20/08/2007, 15h55

Envoyé par lapos

Code :

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

1
2
3
4
5
6
7
8
 
void gestionScrolling(Position *position)
{
    [...]
    stopy = (stopy>NB_BLOCS_LARGEUR)?NB_BLOCS_LARGEUR:stopy; /*Si stopy est plus grand que NB_BLOCS_LARGEUR, il est égale a NB_BLOCS_LARGEUR*/
    stopx = (stopx>NB_BLOCS_HAUTEUR)?NB_BLOCS_HAUTEUR:stopx;/*Idem*/
    [...]
}

L'inversion ne serait-elle pas là ?
Je n'ai pas regardé ce que fait ton programme, mais logiquement, x traite la largeur de l'écran, et y la hauteur, donc il faudrait plutot mettre :

Code :

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

1
2
3
4
5
6
7
 
void gestionScrolling (Position *position) {
    [...]
    stopx = (stopx > NB_BLOCS_LARGEUR) ? NB_BLOCS_LARGEUR : stopx;
    stopy = (stopy > NB_BLOCS_HAUTEUR) ? NB_BLOCS_HAUTEUR : stopy; 
    [...]
}

Un conseil quand tu programmes ainsi, avec deux séries de lignes de codes similaires (ici les traitements sur x et y), mets les toujours dans le même ordre, ça évite les inversions...

Lecture d'un fichier

C

Vue hybride

Discussions similaires

Partager

Partager