Discussion :

[femtosa]

Perso, je trouve que la liste chaînée est la meilleure (ou moins mauvaise préfèrerons certain ! ) des solutions dans ton cas ... J'ai réalisé un jeu de cette manière là avec pas mal d'ennemis ... Ca prends pas tant de ressource que ça avec les performances d'aujourd'hui ! Et si tu fais une fois des bonnes fonctions d'ajout, suppression et parcours de liste chaînée tu seras bien au claire ...

Mais ce n'est qu'un avis (qui j'espère ne lancera pas de débat sur la question ) ! Mais réfléchit bien pour ta solution et une fois la décision prise, ne pense pas aux autres solutions ! Fonce dans celle que t'as choisi sinon tu va perdre trop de temps à réfléchir !

[diogene]

Si tu connais au début de l'exécution (en lisant ton fichier) le nombre d'ennemi, alors un tableau alloué dynamiquement est la méthode la plus simple et la plus efficace.
La question qui je me pose alors est de choisir entre un tableau de structure ennemi ou un tableau de pointeur sur des structures ennemi (allouées dynamiquement).
La première solution impose de marquer si les ennemis sont morts ou vivant dans la structure ennemi et gèle la mémoire allouée aux ennemis qu'ils soient vivants (et c'est normal) ou morts (pourtant ils ne servent plus).
La deuxième solution permet de tuer très facilement un ennemi en récupérant la mémoire qui lui a été allouée puis en marquant à NULL la position du tableau qui lui a été associé. La mémoire gelée est alors le nombre d'ennemi*un pointeur au lieu du nombre d'ennemi*une structure ennemi.

[Elstak]

Me revoilà !!

Fonce dans celle que t'as choisi sinon tu va perdre trop de temps à réfléchir !

oui ! c'est pourquoi j'ai continué sur l'idée de koala

voici finalement mon code final :

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
struct Ennemi* RecupInfoEnnemi(char *NomFic)
{
    FILE *fp = fopen(NomFic,"r");
    int NombreEnnemis;//nombre d'ennemis dont on va récupérer les infos
    int i;
    Ennemi *TableauEnnemi;//tableau d'ennemis (qui contient les info)
    //déclarations nécessaires à la récupération des info du fichier
    char  *endChar;
    char  buffer[MAX_CHAR];
    char  *Repertoire;
 
 
    if( (Repertoire = _getcwd( NULL, 0 )) == NULL )
        perror( "erreur" );
 
    if(NULL == fp)
    {
       printf("Erreur, impossible de trouver le fichier : %s\\%s\n",Repertoire,NomFic);
       exit(-1);
    }
    //on récupère la première ligne qui contient les info du joueur (inutilisée ici)
    fgets(buffer, MAX_CHAR, fp);
 
    //la 2eme ligne contient le nombre d'ennemis
    if(fgets(buffer, MAX_CHAR, fp)==NULL)
    {
        printf("Erreur, impossible de récupérer le nombre d'ennemis");
        exit(-1);
    }
 
 
     NombreEnnemis = strtol(buffer, &endChar, 10);
     printf("nb ennemi : %d\n",NombreEnnemis);//OK!!
     TableauEnnemi = malloc(sizeof(Ennemi)*NombreEnnemis);
     if(TableauEnnemi!=NULL) //allocation réussie
     {
         for(i=0;i<NombreEnnemis;i++)
         {
             TableauEnnemi[i].DernierTour = 0.0; //changer la valeur? voir avec traitements suivants... !!!!
             TableauEnnemi[i].Etat = 1;
             if(fgets(buffer, MAX_CHAR, fp)==NULL)
             {
                 printf("Erreur, impossible de récupérer les infos de l'ennemi : %d",i+1);
                 exit(-1);
             }
 
             TableauEnnemi[i].TypeEnnemi  = strtol(buffer, &endChar, 10);
             TableauEnnemi[i].PositionX = strtol(endChar + 1, &endChar, 10);
             TableauEnnemi[i].PositionY = strtol(endChar + 1, &endChar, 10);      
             printf("Type = %d , PosX = %d , PosY = %d\n",TableauEnnemi[i].TypeEnnemi,TableauEnnemi[i].PositionX,TableauEnnemi[i].PositionY );//OK !
         }
         fclose(fp);
         return TableauEnnemi; 
     }
     fclose(fp);
     return NULL;     
 
}struct Ennemi* RecupInfoEnnemi(char *NomFic)
{
    FILE *fp = fopen(NomFic,"r");
    int NombreEnnemis;//nombre d'ennemis dont on va récupérer les infos
    int i;
    Ennemi *TableauEnnemi;//tableau d'ennemis (qui contient les info)
    //déclarations nécessaires à la récupération des info du fichier
    char  *endChar;
    char  buffer[MAX_CHAR];
    char  *Repertoire;
 
 
    if( (Repertoire = _getcwd( NULL, 0 )) == NULL )
        perror( "erreur" );
 
    if(NULL == fp)
    {
       printf("Erreur, impossible de trouver le fichier : %s\\%s\n",Repertoire,NomFic);
       exit(-1);
    }
    //on récupère la première ligne qui contient les info du joueur (inutilisée ici)
    fgets(buffer, MAX_CHAR, fp);
 
    //la 2eme ligne contient le nombre d'ennemis
    if(fgets(buffer, MAX_CHAR, fp)==NULL)
    {
        printf("Erreur, impossible de récupérer le nombre d'ennemis");
        exit(-1);
    }
 
 
     NombreEnnemis = strtol(buffer, &endChar, 10);
     printf("nb ennemi : %d\n",NombreEnnemis);//OK!!
     TableauEnnemi = malloc(sizeof(Ennemi)*NombreEnnemis);
     if(TableauEnnemi!=NULL) //allocation réussie
     {
         for(i=0;i<NombreEnnemis;i++)
         {
             TableauEnnemi[i].DernierTour = 0.0; //changer la valeur? voir avec traitements suivants... !!!!
             TableauEnnemi[i].Etat = 1;
             if(fgets(buffer, MAX_CHAR, fp)==NULL)
             {
                 printf("Erreur, impossible de récupérer les infos de l'ennemi : %d",i+1);
                 exit(-1);
             }
 
             TableauEnnemi[i].TypeEnnemi  = strtol(buffer, &endChar, 10);
             TableauEnnemi[i].PositionX = strtol(endChar + 1, &endChar, 10);
             TableauEnnemi[i].PositionY = strtol(endChar + 1, &endChar, 10);      
             printf("Type = %d , PosX = %d , PosY = %d\n",TableauEnnemi[i].TypeEnnemi,TableauEnnemi[i].PositionX,TableauEnnemi[i].PositionY );//OK !
         }
         fclose(fp);
         return TableauEnnemi; 
     }
     fclose(fp);
     return NULL;     
 
}

j'ai juste remplacé des noms (plus explicite à mon gout ) et changé quelques tests !

sinon j'aurai un question : pour apres utiliser ma fonction qui récupère les info de ma carte, je devrais savoir à quelle ligne je récupère la taille de la carte... voici la structure de mon fichier (pour etre plus clair) :

position joueur
nombre ennemis
type;coordX;coordY;
...
taille map (nbli=Y !!!;nbcol=X !!!)
(1,1);(1,2)...
...

pour savoir à quelle ligne je recupère cette taille j'ai pensé à ca (mais je trouve pas ca tres beau)

- j'ajoute un parametre à ma fonction ennemi ci dessus qui est "nombreennemi", qui contiendra, apres l'appel, le nombre d'ennemis que j'ai chargés
- j'utilise ce nombre dans ma fonction carte et je fais un truc du genre :
LigneDebut(qui contient taille map) = nombreennemi + 2 (position joueur et nombre ennemis)
- je fais un while (i<LigneDebut) {fgets(buffer, MAX_CHAR, fp);}
ainsi je 'saute' les lignes qui m'interessent pas (c'est ce passage qui me plait pas de trop mais bon c'est juste mon avis )


sinon je peux toujours créer un autre fichier texte mais je préfere pas !

voilà, au fait dans le code que j'ai mis y'a pas mal de tests (inutile, les printf..) que j'ai fait pour tester entre 2 si tout se passait bien

donc merci mon ptit koala (et les autres aussi ) et vive green peace !

Ps : question bonus : dans le code il y a un test qui fait renvoyer un pointeur null en cas d'echec de l'allocation... mais ca peut vraiment arriver ce genre de truc ? enfin jme doute que oui sinon on ferai pas mais je vois pas trop comment, car ca alloue en ram c'est bien ca? donc erreur si ram pleine?

[adil_suptem]

Utilise l'allocation dynamique

[Elstak]

oui, mais encore?

[souviron34]

.... enfin jme doute que oui sinon on ferai pas mais je vois pas trop comment, car ca alloue en ram c'est bien ca? donc erreur si ram pleine?

Oui..

Bon, ça arrive plus souvent sous Windows que sous *n*x (t'as jamais remarqué quand tout gèle ?), mais ça arrive aussi sur *n*x...

Il suffit pour ça de vouloir ouvrir par exemple un très très très gros fichier (par exemple avec un éditeur), et déjà ça fige pas mal, et si en plus tu as 250 autres programmes à côté, ben... Dès que tu dépasses la taille mémoire+swap, badaboum.....

Donc oui ça peut arriver...