Discussion :

[Elstak]

bonjour,

voilà je cherche à créer un jeu dans lequel le nombre d'ennemis est variable selon le niveau dans lequel est le joueur.

je ne sais donc pas combien d'ennemis déclarer au debut...

voici la structure ennemi que j'utilise

Code :

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

1
2
3
4
5
6
7
struct Ennemi{
                int Etat;
                int TypeEnnemi;
                int PositionX;
                int PositionY;
                float DernierTour;
             };

mon problème est que je récupère les données de ces ennemis dans un fichier texte et donc je ne sais pas combien en déclarer au départ... le fichier texte peut etre modifié (je peut ajouter un nombre donnant le nombre d'ennemis dans un niveau si nécessaire...) mais après il me faudrait un truc du genre

Code :

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

1
2
3
4
5
pour k=1 à nombreennemi
    struct ennemi Ennemik
    Ennemik.Etat = la valeur que je récupère....
    ....
fin pour

mon k (ennemik) correspond à l'indice de boucle mais je ne sais pas si c'est faisable, je veux dire utiliser l'indice pour le mettre dans le nom...(oui/non?) ni même si j'ai le droit de déclarer comme ca en C (j'avoue, je trouve ca étrange mais je ne vois pas comment faire autrement!)

Sinon j'avais pensé à une autre idée mais qui n'est pas forcément mieux...

Code :

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

1
2
3
4
5
6
7
struct Ennemi{
                int Etat[xxx];
                int TypeEnnemi[xxx];
                int PositionX[xxx];
                int PositionY[xxx];
                float DernierTour[xxx];
             };

ici j'utilise des tableaux de la manière suivante : PositionX[3] = 2 voudra dire que l'ennemi 3 est en abscisse 2... le problème ici est que je ne sais pas la taille de mes tableaux avant la déclaration de ma structure ( xxx ) et que je devrais la récupérer dans le fichier.

en gros je suis un peu perdu sur la méthode à utiliser... pour moi la seconde me parait meilleure mais j'ai du mal à la coder...

voici pour l'instant le contenu de mon fichier Structures.h :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
#ifndef Structure_H
#define Structure_H
 
const int taille=0;
 
struct Ennemi{
                int Etat[taille];
                int TypeEnnemi[taille];
                int PositionX[taille];
                int PositionY[taille];
                float DernierTour[taille];
             };
#endif

le problème vient de la taille des tableaux... je voulais juste mettre Etat[taillle] puis il m'a demandé de déclarer taille (pas trop étonant) donc je l'ai déclaré et initialisé à 0 (en attendant de récupérer sa valeur dans mon fichier texte) puis il m'a dit "expected constant expression" j'ai tenté de mettre un const à tout hasard mais non...

voilà donc merci d'avance pour vos propositions

[odsen.s]

Salut,

voilà je cherche à créer un jeu dans lequel le nombre d'ennemis est variable selon le niveau dans lequel est le joueur.

Déclare un pointeur sur ta structure, puis assigne de l'espace mémoire avec malloc

[hedi07]

ou alors tu fait une fonction qui te donne le nombre d'ennemi en fopnction du niveau (genre nb_d'ennemi = niveau * 5 + 6),

en suite tu recupere ci nombre que t'appelle u et t'en fait un malloc(u).(dsl j'ai pas pu m'en empecher).

salut

[Elstak]

malloc(u)

hmm...

non c'est aléatoire (enfin ca ne suit pas de fonction)

je pense donc que je devrais faire comme ca

Déclare un pointeur sur ta structure, puis assigne de l'espace mémoire avec malloc

mais les malloc et moi... je dois déclarer ma structure comment? je dois allouer ma mémoire à quel moment? (désolé ca me parait pas évident)

[souviron34]

ben c'est quasiment la base du C..

Regardes les tutoriels, ou ton bouquin...

N'essayes pas de faire du C si tu ne te préoccupes pas d'allocation dynamique...

[koala01]

Salut,

Tu as quantité de manières pour arriver à ce que tu veux...

La premiere, c'est d'utiliser un pointeur sur ta structure et de jouer avec les fonctions malloc/realloc

La deuxième est d'utiliser une structure dynamique (une file, par exemple) et créer un élément de ta file pour chaque lecture

La troisième, que je déconseillerais largement, mais qu'on ne peut (pour etre complet) pas passer sous silence serait l'utilisation d'un tableau dont la taille serait arbitrairement choisie à une valeur qui ne serait jamais atteinte (1024, 2048 ou plus)

Personnellement, j'aurais tendance, surtout si tous les ennemis ne doivent pas appraraitre en meme temps, à utiliser la file (qui fonctionne selon le principe "first in, first out")...

Une simple modification de la structure en

Code :

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

1
2
3
4
5
6
7
8
struct Ennemi{
                int Etat;
                int TypeEnnemi;
                int PositionX;
                int PositionY;
                float DernierTour;
                struct *Ennemi;
             };

et la mise en place d'une fonction "init" (permettant de créer la file sur base du fichier) et d'une fonction "suppress" (permettant de supprimer un élément de la file) suffiront à te permettre une adaptation à tous les cas de figure

[Elstak]

N'essayes pas de faire du C si tu ne te préoccupes pas d'allocation dynamique...

oui je sais bien

La troisième, que je déconseillerais largement, mais qu'on ne peut (pour etre complet) pas passer sous silence serait l'utilisation d'un tableau dont la taille serait arbitrairement choisie à une valeur qui ne serait jamais atteinte (1024, 2048 ou plus)

j'y avais pensé au début

Personnellement, j'aurais tendance, surtout si tous les ennemis ne doivent pas appraraitre en meme temps, à utiliser la file

si, ils sont toujours tous visibles

je vois à peu près le truc pour allouer l'espace (je sais plus la syntaxe exacte mais ca doit etre un malloc(MonNombre * sizeof(ennemi)) mais apres je suis un peu perdu

Edit:

oui c'est bon avec le pointeur sur ennemi... je repars continuer et je reviendrai surement pour un peu d'aide

[Elstak]

Une simple modification de la structure en

Code :

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

1
2
3
4
5
6
7
8
struct Ennemi{
                int Etat;
                int TypeEnnemi;
                int PositionX;
                int PositionY;
                float DernierTour;
                struct *Ennemi;
             };

et la mise en place d'une fonction "init" (permettant de créer la file sur base du fichier) et d'une fonction "suppress" (permettant de supprimer un élément de la file) suffiront à te permettre une adaptation à tous les cas de figure

j'essaie d'utiliser cette solution mais je ne vois pas comment la mettre en oeuvre (les fonctions init et suppres par exemple je vois pas trop...) par la suite je ne vois non plus comment retrouver un ennemi en particulier

[koala01]

Ben, on peut, par exemple, prévoir une fonction init dont la logique serait

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
 
/* fonction d'initialisation du niveau
 * @in: nom du fichier à lire
 * @out pointeur sur le premier élément de la pile/file/liste
 */
 
Enemi* Init(const char* name)
|    fichier=OuvrirFichier(name, lecture)
|    Enemi* debut<-- NULL
|    Enemi* fin<-- NULL
|    Enemi* temp<-- NULL
|    SI fichier ouvert
|    |    Tant que (lire fichier)
|    |    |    temp<-- allouer Enemi
|    |    |    SI temp != NULL
|    |    |    |    Lire temp->Etat dans fichier
|    |    |    |    Lire temp->TypeEnnemi dans fichier
|    |    |    |    Lire temp->PositionX dans fichier
|    |    |    |    Lire temp->PositionY dans fichier
|    |    |    |    Lire temp->DernierTour
|    |    |    |    temp->suivant <-- NULL
|    |    |    |    SI debut= NULL
|    |    |    |    |    debut<-- temp
|    |    |    |    FIN SI
|    |    |    |    SI fin!=NULL
|    |    |    |    |    fin->suivant <-- temp
|    |    |    |    FIN SI
|    |    |    |    fin<-- temp
|    |    FIN TANT
|    |   Fermer fichier
|    FIN SI
|    renvoyer debut

Bref, rien de beaucoup plus compliqué qu'une initialisation de structure dynamique classique au départ d'un fichier

La fonction de suppression suivrait la logique "classique" de la suppression dans une structure dynamique:

• chercher l'élément à supprimer
• "écarter" l'élément à supprimer de la structure
• Libérer la mémoire allouée à l'élément à supprimer
• Renvoyer un pointeur sur le début de la structure dynamique, pour le cas où il aurait changé

Bref, ces deux fonctions ne sont jamais que la mise en oeuvre des algorithmes habituellement utilisés quand on envisage d'utiliser des structures dynamiques

[Elstak]

merci mon petit mangeur d'eucalyptus !

je vais essayer un peu pour voir sque ca donne

sinon je comprend pas un ptit truc :

SI fin!=NULL

au debut on l'initialise à NULL et jamais on lui affecte autre chose donc jamais il sera différent? ou alors j'ai pas saisi un truc...

[koala01]

Au début, on initialise fin à NULL...

Or, si on tente un acces à fin->suivant quand fin vaut NULL, c'est le plantage assuré (segvault)

Donc, il ne faut fournir une variable non null pour fin->suivant que... si fin ne vaut pas NULL (autrement dit, si ce n'est pas le premier élément que l'on place dans la structure)...

Bref, il n'y a pas de quoi fouetter un... programmeur

[Elstak]

me revoilà,

je suis allé voir un peu les tuto sur les listes.
je vois pas trop quand utiliser un certain type de liste plutot qu'un autre.

dans mon cas je veux pouvoir lister tous les ennemis et les retirer de la liste si ils meurent (je dois bien faire comme ca, hein? )

donc le type pile ne convient pas de trop car je peux retirer que le dernier ajouté? donc plutot un autre.... par exemple j'ai vu une liste triée... si je donne à chaque ennemi un numéro comme une sorte d'identifiant (je rajoute un int indentifiant dans ma structure et je les classe grace à ca) ca irait?

désolé j'ai jamais utilisé de listes donc je suis un peu perdu

PS : si possible (et si ca existe) collez moi un ptit lien vers un tuto correspondant

[souviron34]

ben faut chercher un peu.. Ici il y a (presque) tout :

liste chaînée simple :

http://chgi.developpez.com/pile/

liste chaînée double :

http://nicolasj.developpez.com/articles/listedouble/

[Elstak]

oui je sais bien qu'il les a toutes... j'ai regardé mais en fait je sais pas trop quel type de liste utiliser pour mon cas

[souviron34]

la double est le plus rapide et pratique, mais prend plus de mémoire..

Sinon, le tableau, .... Par contre, ajouter se fera à la fin, et enlever pourra prendre du temps (il faudra tasser la fin du tableau d'un cran). Mais tu peux avoir un accès direct, et ça prend un peu moins de mémoire (entre 1 et 2 pointeurs de moins à chaque fois).

[koala01]

En fait, chaque manière d'envisager les choses a ses avantages, mais surtout ses inconvéniants...

Ainsi, l'utilisation de tableaux permettra d'avoir un acces "aléatoire" aux éléments (tu peux tout de suite accéder à l'élément[n]), mais prendra du temps lors de l'ajout s'il faut redimentionner le tableau, et du retrait...

La liste (simplement ou doublement chainée) facilitera l'ajout et le retrait d'éléments, mais demandera plus de temps pour l'acces, du fait qu'il est plutot "séquentiel" (on doit passer par tous les éléments qui séparent celui sur lequel on se trouve et celui auquel on veut accéder)

L'arbre binaire, dont on n'a pas encore parlé jusqu'à présent, permettra une recherche "dichotomique" (donc tres rapide, de l'ordre de O(logn) ), à condition qu'il soit correctement trié et rempli... ce qui peut prendre d'autant plus de temps que le nombre d'éléments est important

Ceci dit, si les "monstres" sont déjà correctement triés dans le fichier, la séquence d'ajout dans un arbre binaire peut etre relativement rapide (vu qu'on part du principe que tu liras sans doutes tous les monstres au début du niveau )

Et il ne faut pas oublier que la suppression d'un "noeud" de l'arbre qui ne serait pas "une feuille" peut également prendre un temps d'autant plus important que le noeud à supprimer contient de nombreux enfants et descendants...

Pour le reste, la décision de la manière à utiliser reste tres arbitraire et dépendra principalement de ce que TU auras déterminé comme "point d'étranglement" en fonction des différentes actions de gestion de tes monstres, et de leur fréquence...

Par exemple, si tu sais à tout moment à quel monstre tu veux accéder, sachant que tu les créerais d'office lors du chargement du niveau, le tableau pourrait etre la meilleure solution (si on évite les suppressions... mais un simple "flag" (vivant/mort) pourrait nous permettre de les éviter )

Si, par contre, tu ne sais jamais à quel monstre il faut accéder, et que cela nécessite une recherche, l'arbre binaire pourrait permettre de trouver rapidement celui qui t'intéresse... Ici encore, le fait de s'éviter les suppressions avec un flag serait de nature à faciliter les choses

Enfin, si l'acces se fait principalement "de proche en proche" (du 5eme élément, on passe au 6eme ou au 7eme) la liste chainée (simplement si l'acces est uniquement incrémental, doublement si l'acces peut aussi bien etre incrémental que décrémental) présentera des performances raisonnables, tout en permettant la suppression sans avoir besoin de recourrir à un flag...

Comme tu le vois, il y a trois solutions et trois raisons de choisir plutot l'une que l'autre... Pour le reste, à toi de jouer

[Elstak]

bah en fait je vais le faire en tableau je pense

Par exemple, si tu sais à tout moment à quel monstre tu veux accéder, sachant que tu les créerais d'office lors du chargement du niveau, le tableau pourrait etre la meilleure solution (si on évite les suppressions... mais un simple "flag" (vivant/mort) pourrait nous permettre de les éviter )

mon :

Code :

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

int Etat;

de ma structure ennemi, cetai en fait prévu pour contenir un booléen qui indique si l'ennemi est mort ou non. Mais je manque de méthode pour faire ce tableau... en fait au début de mon fichier texte je ne sais pas combien j'aurai d'ennemis, ils sont stockés sur une ligne par exemple :

Code :

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

1;2;3;2;3;4;

là il y aura 2 ennemis. le premier de type=1 positionX=2 positionY=3 (les autre données sont initialisées à 0.

donc pour le malloc je sais pas trop comment faire... car je vais lire '1' puis '2' puis '3' puis '2'... donc je sais pas quand j'aurai NULL, le malloc est obligé de se faire en 1 fois? ou je peux faire un truc du genre :

Code :

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

1
2
3
4
5
6
7
malloc (sizeof(struct ennemi));
//je recup les info du premier
while(caractere suivant!=NULL) //le car suivant est le premier car de l'ennemi d'apres
{
malloc(sizeof(struct ennemi));
//recup info
}

c'est possible ca?
désolé, chui pas encore un pro du malloc

[koala01]

Honnetement, si tu te diriges vers un tableau pour maintenir tes ennemis, l'idéal est peut etre de revoir le format de ton fichier...

La première information que tu devrais lire dans ton fichier n'étant autre que... le nombre d'enemis qu'il faudra lire
Ainsi, tu pourrais envisager un fichier texte du genre de

Code :

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

1
2
3
4
5
6
 
35
2,5,10
2,15,30
1,1,1
(...)

qui signifierait:
35 enemis à lire dont:
le premier est de type 2, a la position (5,10)
le deuxième est de type 2, a la position (15,30)
le troisième est de type 1, à la position (1,1)
...

Et tu commencerais ton code sous la forme d'un truc ressemblant à

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
 
/** fonction qui lit le fichier et initialise les enemis
  * @in: nom du fichier à lire
  * @out: pointeur sur le premier élément du tableau
  */
struct Enemi* LireNiveau(const char* filename)
{
    FILE* fichier=fopen(filename,'r');
    if(fichier!=NULL)
    {
        int combien;/* le nombre d'enemi à lire */
        int i;/* le compteur pour la boucle */
        Enemi *toread; /* pour le tableau d'enemis */
        fscanf(fichier,"%d",&combien);
        /* tentative d'allocation de la mémoire pour tous les enemis */
        toread=malloc(sizeof(Enemi) *nombre);
        if(toread!=NULL)
        {
             /* l'allocation a réussi, on entre dans la boucle d'initialisation
              * des enemis au départ du fichier (d'autres solutions peut etre
              * meilleures existent sans doute :D)
              */
             for(i=0;i<nombre;i++)
             {
                  /* d'abord les valeurs qu'on ne lira pas dans le fichier */
                  toread[i].Etat=1;
                  toread[i].DernierTour=0.0;/* quelle valeur veux tu donner???*/
                  /* puis les valeurs qu'il faut lire dans le fichier */
                  fscanf(fichier,"%d,%d,%d",&toread[i].TypeEnnemi,
                                            &toread[i].PositionX,
                                            &toread[i].PositionY);
             }
             /* on peut fermer le fichier, et renvoyer toread */
             fclose(fichier);
             return toread;
        }
        /* arrivé ici, l'allocation a échoué... on ferme le fichier et on 
         * renvoie NULL
         * ce sera à gérer dans la fonction appelante ;)
         */
        fclose(fichier);
        return NULL
    }
    /* arrivé ici, l'ouverture du fichier a échoué... on renvoie NULL
     * (problème a traiter dans la fonction appelante)
     */
    return NULL;
}

Si le format est définitif - peut etre parce que tu as déjà prévu trop de niveaux - il n'y a rien qui t'empeche de lire le fichier en te servant d'une liste et en comptant chaque ajout (un simple compteur suffit) puis d'allouer la mémoire suffisante pour contenir l'ensemble des enemis, avant de les recopier de la liste vers le tableau (en n'oubliant pas, de préférence, de libérer la mémoire qui a été allouée pour la liste )

Arrivés à ce point de la discution, il est important de prendre conscience que:

• je suis plutot C++, et j'ai donc un peu perdu l'habitude de lire dans des fichiers en C (suis pas sur du tout de mon fscanf )
• Je ne prétend absolument pas que les solutions proposées "sont les meilleures", ni meme qu'elles peuvent prétendre à etre nominées pour le podium... je m'efforce juste de t'orienter vers des solutions qui peuvent, en quelques secondes de réflection, sembler correspondre à ce que tu cherche

[Elstak]

yeap,

non j'ai juste fait un seul fichier donc je peux changer le format sans problème !
par contre pour la solution que tu propose ma structure ennemi doit etre comme ca :

struct Ennemi{
int Etat;
int TypeEnnemi;
int PositionX;
int PositionY;
float DernierTour;
};

c'est bien ca?

sinon ensuite j'ai aussi les données de la carte à remplir. du style

1;1;2;1;
1;2;1;1;

chaque entier correspondant à un type de terrain (exemple : 2 = obstacle...)
donc tu me conseillerais aussi de mettre la dimension de la carte dans le fichier texte, non?

j'aurais donc :

Code :

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

1
2
3
4
5
6
7
8
9
 
35 //nombre ennemis
4;5 //4 lignes et 5 col donc Carte[4][5]
2;3;4 //mes données ennemi
....
1;1;1;1;1 //carte
1;1;2;1;1
1;1;1;1;1
1;1;1;1;1

un truc de ce genre?

[koala01]

Oui, oui... et oui

Meme si, personnellement, j'aurais tendance à séparer les données concernant la carte et celles concernant les ennemis...

Ou encore à mettre d'abord le nombre d'ennemis, suivi des informations les concernant, puis à metre le nombre de cases de la carte, suivi des informations qui les concernent... ou peut etre l'inverse (car il vaut mieux avoir la carte avant de vouloir y mettre les monstres )

A partir du moment où tu n'es pas tenu de te conformer à un format précis, et c'est le gros avantage de "partir de rien" (car il en faut bien un, quand meme ) tu es libre de faire exactement à ton gré, de prévoir un format de fichier selon ton humeur, ou selon tes propres spécifications...

Seulement, encore une fois, cela nécessite

• plus de réflection qu'un format dont les spécifications sont connues
• une étape de spécification et de conception beaucoup plus longue, car toutes les limites que tu te sera posées "sans meme y penser ni t'en appercevoir" finiront à un moment ou un autre par te revenir en pleine poire