Sujet Précédent Sujet Suivant

[C - SDL] Lire un fichier texte

Résolu/Fermé
Kimimarusama - 30 avril 2010 à 17:42
 Scipion - 30 avril 2010 à 21:32


Bonjour à tous, j'ai un petit problème dans un projet de Mario!
J'ai réussi à faire toute la partie "éditeur" où je créer ma map à l'écran et je la sauvegarde ensuite dans un fichier texte sous cette forme:

0000000000000000000000000000000000000000000000000000000000000000000009
0000000000000300000000000000000330000000000002222000000000000000000008
0000000000000000000000000000000000000000000022002200000000002222200008
0000000000002220000000000000000000000000000000000000000000000000000008
0000000000000000000032220000022222200000022000000002200022000000000067
0000000022200000000000000000000000000000000000330000000000000000000045
0000000000000000000000000000000000000000000000000000000000000000000045
0000000000000000006700000000000000000222222000000002222220000000000045
0000222200000000004500002220000000000000000000220000000000000000000045
0000000000000000004500000000000006700000000000000000000000000000000045
0000000000000000004500000000000004500000000000000000000000000000000045
1111111111111111114511111111111114511111111111111111111111111111111111


où chaque chiffre correspond à une image différente...
Mon problème se situe dans la partie "jeu" qui consiste tout d'abord à lire ce fichier texte afin de générer le monde où mon Mario progresse...
J'ai essayé différentes méthodes toutes infructueuses jusque là...

Méthode N°1: 


#include <stdlib.h>
#include <stdio.h>
#include <SDL.h>
#include <SDL_image.h>

#include "constantes.h"
#include "fichier.h"

int chargerNiveau(int niveau[][NB_BLOCS_HAUTEUR])
{
    FILE* fichier = NULL;
    char ligneFichier[NB_BLOCS_LARGEUR * NB_BLOCS_HAUTEUR+1] = {0};
    int i = 0, j = 0;

    fichier = fopen("niveaux.txt", "r");

    fgets(ligneFichier, NB_BLOCS_LARGEUR*NB_BLOCS_HAUTEUR+1, fichier);

    for(i = 0 ; i <NB_BLOCS_LARGEUR ; i++)
    {
        for (j = 0 ; j < NB_BLOCS_HAUTEUR ; j++)
        {
            switch (ligneFichier[(i * NB_BLOCS_LARGEUR) + j])
            {
                case '0':
                    niveau[j][i] = 0;
                    break;
                case '1':
                    niveau[j][i] = 1;
                    break;
                case '2':
                    niveau[j][i] = 2;
                    break;
                case '3':
                    niveau[j][i] = 3;
                    break;
                case '4':
                    niveau[j][i] = 4;
                    break;
                case '5':
                    niveau[j][i] = 5;
                    break;
                case '6':
                    niveau[j][i] = 6;
                    break;
                case '7':
                    niveau[j][i] = 7;
                    break;
                case '8':
                    niveau[j][i] = 8;
                    break;
                case '9':
                    niveau[j][i] = 9;
                    break;
                default:
                    break;
            }
        }
    }

    fclose(fichier);
    return 1;
}



Méthode N°2: 


#include <stdlib.h>
#include <stdio.h>
#include <SDL.h>
#include <SDL_image.h>

#include "constantes.h"
#include "fichier.h"

int chargerNiveau(int niveau[][NB_BLOCS_HAUTEUR])
{
    FILE* fichier = NULL;
    int i = 0, j = 0;

    fichier = fopen("niveaux.txt", "r");

    for(i = 0 ; i <NB_BLOCS_LARGEUR ; i++)
    {
        for (j = 0 ; j < NB_BLOCS_HAUTEUR ; j++)
        { niveau[i][j] = fgetc(fichier)-'0';}
    }

    fclose(fichier);
    return 1;
}



J'ai certainement tenté d'autres méthodes mais qui ne donnaient pas du tout de résultats convaincant!!
Je ne pense pas qu'il y ai des problèmes dans le code lui-même mais plutôt dans la méthode...

J'attends vos commentaires, et je l'espère une/des solution(s) à mon problème...
Merci d'avance!
A voir également:

12 réponses

Réponse 1 / 12
Scipion
30 avril 2010 à 21:23
Oui, mais ça c'est juste pour voir si ça marche.

Il faut adapter le code à tes besoins. Voila la procedure complete que j'ai nommé restaurerNiveau. 

int restaurerNiveau()
{
   FILE* fichier = NULL;
    int i = 0, j = 0;

//declarer une variable de type char avec une longueur suffisante
    char ligne [256];

    fichier = fopen("niveaux.txt", "r");

    for (i = 0 ; i < NB_BLOCS_HAUTEUR ; i++)
    {

//lire une ligne entière maximum 256 caractères ou jusqu'à \n
        fgets(ligne,256,fichier);

        for (j = 0 ; j < NB_BLOCS_LARGEUR ; j++)

//lire chaque caractère (byte: entier codé sur un octet, c'est le code ascii du caractère)
//soustraire 48 (code ascii du caractère '0')
//stocker le resultat dans le tableau niveau

        {niveau[j][i]=ligne[j]-48;}

    }

    fclose(fichier); 
return 1;
}


Après, il te faut une procédure qui redessine le monde d'après le tableau ...

Si ça ne marche pas, dis moi ou ça plante.
1
Réponse 2 / 12
Scipion
30 avril 2010 à 18:20
Bonjour,

La bonne methode pour recuperer la sauvegarde est de faire la démarche inverse de celle qui t'as permis de créer le fichier.

Quel code as-tu utilisé?

Slt.
0
Réponse 3 / 12
Kimimarusama
30 avril 2010 à 18:25
J'ai utilisé ce code: 


int sauvegarderNiveau(int niveau[][NB_BLOCS_HAUTEUR])
{
    FILE* fichier = NULL;
    int i = 0, j = 0;

    fichier = fopen("niveaux.txt", "w");

    for (i = 0 ; i < NB_BLOCS_HAUTEUR ; i++)
    {
        for (j = 0 ; j < NB_BLOCS_LARGEUR ; j++)
        { fprintf(fichier, "%d", niveau[j][i]);}
        fprintf(fichier,"\n");
    }

    fclose(fichier);
    return 1;
}
0
Réponse 4 / 12
Scipion
30 avril 2010 à 19:00
d'après ce que je vois, tu ecris successivement des entiers issus de ton tableau niveau dans une ligne de texte

l'inverse serait de lire une ligne de texte et de transformer chaque caractère en un entier et le stocker dans ton tableau niveau

ça donnerait: 

    FILE* fichier = NULL;
    int i = 0, j = 0;

//declarer une variable de type char avec une longueur suffisante
    char ligne [256];

    fichier = fopen("niveaux.txt", "r");

    for (i = 0 ; i < NB_BLOCS_HAUTEUR ; i++)
    {

//lire une ligne entière maximum 256 caractères ou jusqu'à \n
        fgets(ligne,256,fichier);

        for (j = 0 ; j < NB_BLOCS_LARGEUR ; j++)

//lire chaque caractère (byte: entier codé sur un octet, c'est le code ascii du caractère)
//soustraire 48 (code ascii du caractère '0')
//stocker le resultat dans le tableau niveau

        {niveau[j][i]=ligne[j]-48;}

    }

    fclose(fichier);


si mes souvenir du C sont bons ça devrait marcher.
A+.
0

Vous n’avez pas trouvé la réponse que vous recherchez ?

Posez votre question
Réponse 5 / 12
Kimimarusama
30 avril 2010 à 19:09
J'ai essayé ta technique...

Il y a de l'idée, mais c'est comme les deux méthodes que j'ai expérimenté, ça ne marche pas comme cela devrait...
0
Réponse 6 / 12
Scipion
30 avril 2010 à 19:17
Je fais un test avec le modèle de sauvegarde que t'as mis plus haut et je te dis ce qu'il en est.

A+
0
Réponse 7 / 12
Scipion
30 avril 2010 à 20:10
Alors voila les resultats du test.
un petit programme qui illustre comment decoder ton fichier. 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main()
{
//pour l'exemple je cree un tableau de 2 lignes de texte
char ligne [2][256];
int i,j;
int niveau[2][70];
//initialisation du taleau de texte , en fait c'est comme un fichier"
strcpy (ligne[0],"0000000000000000004500000000000004500000000000000000000000000000000045");
strcpy (ligne[1],"1111111111111111114511111111111114511111111111111111111111111111111111");

	 for (i = 0 ; i < 2 ; i++)
	 {
		  for (j = 0 ; j < 70 ; j++)

//lire chaque caractère (byte (entier codé sur un octet, c'est le code ascii du caractère)
//soustraire 48 (code ascii du caractère '0')
//stocker le resultat dans le tableau niveau

	                 {niveau[i][j]=ligne[i][j]-48;}}


//imprimer le contenu du taleau niveau pour verifier
	 for (i = 0 ; i < 2 ; i++)
	 {
		  for (j = 0 ; j < 70 ; j++)
	                 {printf("%d",niveau[i][j]);}
                  printf("\n");
	  }

return 1;
}


A+.
0
Réponse 8 / 12
Kimimarusama
30 avril 2010 à 20:21
Cela marche très certainement et je comprends le code!
Mais ça ne peut pas répondre à mon problème puisque je ne peux pas lire le fichier texte où j'ai enregistrer le monde créer dans l'éditeur!

Je n'ai jamais utilisé la fonction "strcpy" et donc je ne sais pas s'il est possible de la "coupler" avec gets par exemple pour lire le fichier texte...

Penses-tu que quelque chose comme ça serai possible?
0
Réponse 9 / 12
Scipion
30 avril 2010 à 20:28
...je ne peux pas lire le fichier texte où j'ai enregistrer le monde...

Je ne te suis pas.

Le fichier est-il bien créé avec le format indiqué?
Si oui qu'est ce qui t'empeche de le lire?
0
Réponse 10 / 12
Kimimarusama
30 avril 2010 à 21:07
Ce que je veux dire, c'est qu'avec le code que tu m'as donné, je dois initialiser ligne[i] "manuellement" alors que normalement sa devrais se faire tout seul en fonction du fichier texte où est sauvegarder la map...

Ce qui me gène ce n'est que ça: 

strcpy (ligne[0],"0000000000000000004500000000000004500000000000000000000000000000000045");
strcpy (ligne[1],"1111111111111111114511111111111114511111111111111111111111111111111111");



A moins que je n'ai pas bien compris ton code, ces lignes remplacent la lecture du fichier texte...
0
Réponse 11 / 12
Kimimarusama
30 avril 2010 à 21:30
Merci beaucoup! :)

Je sais que ce code tu me l'avais déjà donné, mais c'est: Après, il te faut une procédure qui redessine le monde d'après le tableau ... qui m'as donné "la solution"!

J'ai juste modifié la manière de dessiner le monde justement et ça à l'air de marcher sans problème! :)

Désolé, je suis un peu un boulet...
0
Réponse 12 / 12
Scipion
30 avril 2010 à 21:32
OK, bonne continuation...
0

Discussions similaires

comment donner les droits sur fichier partage
ch'ti du 57 -
fil1958 -

2 réponses