Bonjour,
mon problème est très simple (enfin je crois ) je code un jeu en 2D et plusieurs images pourront correspondre à une même entité physique (genre un mur quoi). Du coup je n'ai pas envie de rajouter une ligne de test pour chaque nouvelle couleur de mur et vu que je ne sais pas encore combien il y en aura je veux pouvoir me permettre d'en rajouter en toute simplicité.
J'utilise la SDL (je ne pense pas que ça changera grand chose vu que le problème est plus dans le C mais peut-être y a t-il une fonction prédéfinie) et chaque objet est définie par une énumération :
enum{VIDE, MUR1, MUR2, TORCHE, HEROS} (comme dans le cours de mateo21 en somme )
et ensuite dans les test j'ai if(test_logique == MUR1)

Le problème est Le personnage peut passer une case TORCHE ou VIDE mais pas MUR1 ou MUR2 je ne peux donc pas faire de != VIDE sans devoir rajouter une condition pour chaque autre case qu'il pourra traverser. Je me demandais donc si il n'y avait pas un moyen de faire une sorte de "classe" qui marcherait un peu comme ça : if(type.(test_logique) == mur) et MUR1.type = mur MUR2.type = mur.
Ce qui me simplifirait grandement la tache

Autre contrainte, les types d'objet doivent être contenu dans un fichier "constantes.h" puisqu'ils sont appelés dans plusieurs autres fichier et que je n'ai pas envie d'envoyer 800 variables à chaque appel de fonction. Il faudrait que cela marche un peu comme un enum en somme.
Si quelqu'un a une solution je le remercie grandement

J'ai peut etre mal compris, et pas de code pour vérifié, donc peut etre j'vais dire n'importe quoi

Alors tu peux créer une structure décors, avec le type de décors, sa position (si nécessaire) et le numéro de l'image associé.

Rappel structure :
http://openclassrooms.com/courses/apprenez-a-programmer-en-c/creez-vos-propres-types-de-variables
http://www.commentcamarche.net/contents/119-les-structures-en-langage-c
http://c.developpez.com/cours/bernard-cassagne/node80.php

Exemple utilisation dans le cas que tu décris ( du moins je crois )

//toute les images du décors sont chargées une seule fois ( et seront blittées autant de fois qu'il faut)
// a mettre dans le fichier .c ou tu fera les blit.
SDL_image *tabImage[x]={SDL_load(imageMur1), SDL_load(imageMur2),SDl_Load(imageTorche),...};


// a mettre dans constante.h

//enumeration pour test
enum typeDecor{MUR, TORCHE, VIDE, AUTRE}

//structure d'un objet du décors ( c'est un exemple, tu peux mettre d'autre info ou en enlevé)
typedef struct decors
{
    typeDecor type; //type du décors: mur ou torche ou ... les différents type de mur sont des murs ( même propriétés donc dans enum MUR suffit )
    int   posX; //position en x 
    int   posY;  //position en y 
    int    numImage;  //indice de l'image dans tabImage à blitter 
};

Comme tu parle de mateo et que tu n'a rien mentionné sur ta façon de stocker la map et de la parcourir. Je pars du principe que ta structure de donnée (map) est un tableau à deux dimensions de type décors.
Pour tester tu ecrira:

if(map[x][y].type == MUR)
{
//on traverse pas
}

if(map[x][y].type == VIDE)
{
//on traverse 
}

if(map[x][y].type == TORCHE)
{
//on traverse + on prend torche
}

if(map[x][y].type == AUTRE)
{
//autre chose :noel: 
}

 

Sinon tu peux faire une autre structure sans avoir besoin d'enum. Finalement, d'apres ce que j'ai compris t'as juste besoin de savoir si on peux traverser ou pas alors:

typedef struct decors
{
    bool estTraversable; //false si faux , true si vrai 
    int   posX; //position en x 
    int   posY;  //position en y 
    int    numImage;  //indice de l'image dans tabImage à blitter 
};

pour tester tu ecrira:

if(map[x][y].estTraversable == false)
{
//on traverse pas
}
else
{
//on traverse 
}

Les structures que j'ai ecris sont des exemples adapte en fonctions de tes besoins.

Perso j'aime bien faire une fonction simple du genre bool walkable(int x, int y) ( ou avec la sfml j'utilise Vector2i)

donc j’envoie les coordonné de la case et cette fonction me renvoi un true si la case est "traversable" et un false si elle ne l'est pas ainsi quand je veux tester un déplacement j'ai juste a faire

if(walkable(x,y))

la fonction est simplement composé d'un if qui verifie la case du tableau :
if(tableau[x][y] == MUR || tableau[x][y] == VIDE)
return false;
else
return true;

ça permet de gagner pas mal de ligne et de clarté dans les autres partie de ton code

Le 27 février 2015 à 02:47:08 bugar a écrit :
J'ai peut etre mal compris, et pas de code pour vérifié, donc peut etre j'vais dire n'importe quoi

Alors tu peux créer une structure décors, avec le type de décors, sa position (si nécessaire) et le numéro de l'image associé.

Rappel structure :
http://openclassrooms.com/courses/apprenez-a-programmer-en-c/creez-vos-propres-types-de-variables
http://www.commentcamarche.net/contents/119-les-structures-en-langage-c
http://c.developpez.com/cours/bernard-cassagne/node80.php

Exemple utilisation dans le cas que tu décris ( du moins je crois )

//toute les images du décors sont chargées une seule fois ( et seront blittées autant de fois qu'il faut)
// a mettre dans le fichier .c ou tu fera les blit.
SDL_image *tabImage[x]={SDL_load(imageMur1), SDL_load(imageMur2),SDl_Load(imageTorche),...};


// a mettre dans constante.h

//enumeration pour test
enum typeDecor{MUR, TORCHE, VIDE, AUTRE}

//structure d'un objet du décors ( c'est un exemple, tu peux mettre d'autre info ou en enlevé)
typedef struct decors
{
    typeDecor type; //type du décors: mur ou torche ou ... les différents type de mur sont des murs ( même propriétés donc dans enum MUR suffit )
    int   posX; //position en x 
    int   posY;  //position en y 
    int    numImage;  //indice de l'image dans tabImage à blitter 
};

Comme tu parle de mateo et que tu n'a rien mentionné sur ta façon de stocker la map et de la parcourir. Je pars du principe que ta structure de donnée (map) est un tableau à deux dimensions de type décors.
Pour tester tu ecrira:

if(map[x][y].type == MUR)
{
//on traverse pas
}

if(map[x][y].type == VIDE)
{
//on traverse 
}

if(map[x][y].type == TORCHE)
{
//on traverse + on prend torche
}

if(map[x][y].type == AUTRE)
{
//autre chose :noel: 
}

 

Sinon tu peux faire une autre structure sans avoir besoin d'enum. Finalement, d'apres ce que j'ai compris t'as juste besoin de savoir si on peux traverser ou pas alors:

typedef struct decors
{
    bool estTraversable; //false si faux , true si vrai 
    int   posX; //position en x 
    int   posY;  //position en y 
    int    numImage;  //indice de l'image dans tabImage à blitter 
};

pour tester tu ecrira:

if(map[x][y].estTraversable == false)
{
//on traverse pas
}
else
{
//on traverse 
}

Les structures que j'ai ecris sont des exemples adapte en fonctions de tes besoins.

je crois que tu as tout compris mais comment je fais pour la struct décors? Parce qu'avec une structure je suis obligé de déclarer des variables du type struct decors. Du coup pour chaque nouvel objet il va falloir que je lui donne un nom de variable, sauf que je stocke comme tu l'as deviné dans un tableau à 2 dimensions. et donc map[x][y].type ce sera 1.type par exemple non?

justement, quand tu fait un enum il attribue automatique une valeur a tes enum, par exemple enum{MUR,VIDE,SOL}

MUR = 0
VIDE = 1
SOL = 2

donc quand tu rempli ton tableau tu peut faire :
tableau[x][y] = MUR

Non tu as pas du bien saisir l’intérêt d'une structure et ce que c'est. Je t'ai mis les liens vers des tuto explicatifs.

Une structure c'est un type personnaliser

de base, en C , tu as les types suivant :
int
char
double
float
....( il y en a plus que ca)

tu peux créé des types personnalisé via typedef
exemple:

typedef int bool;

void main()
{
  bool test = 0;

 if(test==0)
{
printf(":noel:");
}
else
printf(":hap:");
} 

tu peux aussi via enum

enum bool {false,true};

void main()
{
  bool test = false;

 if(test==false)
{
printf(":noel:");
}
else
printf(":hap:");
} 

mais c'est limité niveau personnalisation. Alors tu peux utiliser des structures. Qui sont des types et s'utilise comme tel.
A la différence c'est que ces types sont composés de plusieurs autre type ( de base ou non).

definition: ( le langage C - Kernighan, Ritchie - dunod)

Une structure est un objet composé d'une séquence de membres de types divers, portant des noms.

Donc Ton tableau sera de type decors

//declaration de la map
decors map[x][y];


typedef enum typeDecor{MUR,VIDE,TORCHE, AUTRE};

//initialisation de la map via lecture dans un fichier

ouverture_fichier();
tant qu'on est pas  à la fin faire
{
  si MUR alors
  {
   map[x][y].type =MUR;
   map[x][y].posX = x
   map[x][y].posY = y
  map[x][y].numTexture = 1
  }

  si MUR1 alors
  {
   map[x][y].type =MUR;
   map[x][y].posX = x
   map[x][y].posY = y
   map[x][y].numTexture = 2
   }

  si TORCHE alors
  {
    map[x][y].type =TORCHE;
   map[x][y].posX = x;
   map[x][y].posY = y;
   map[x][y].numTexture = 3;
  }

  si VIDE alors
  {
    map[x][y].type =VIDE;
   map[x][y].posX = x;
   map[x][y].posY = y;
   map[x][y].numTexture = 4;
   }

fermeturefichier();

}

Donc dans une structure tu peux mettre tout et n'importe quoi. Apres faut bien voir si c'est utile ou non.

unitedelite29 te propose juste une enumeration simple, ca peux faire l'affaire evidement, mais ca dépend tes besoins et de ton organisation.

typedef enum typeDecor{MUR,MUR1,VIDE,TORCHE, AUTRE};

typeDecor map[x][y];

si map[x][y]==MUR alors{}
si map[x][y]==MUR1 alors{}
si map[x][y]==VIDE alors{}
si map[x][y]==TORCHE alors{}

d'apres ce que j'ai compris tu as plusieurs textures, soit comme unitedelite29 le propose tu fais une enumeration avec tous les types et autant de test que de valeu pour l'affichage et les collisions.

Soit comme je te propose une structure dans laquelle tu stocke les informations de texture, et de traversabilité. Ca reduiera les test de collision et d'affichage r( dans le sens ou il y a moins à ecrire) et c'est plus générique à ce niveau la.

par exemple avec ma méthode:

//notre structure
typedef struct decors
{
    bool estTraversable; //false si faux , true si vrai 
    int    numTexture;  //indice de l'image dans tabImage à blitter 
};

...


//tableau avec tte les textures
sdl_surface tabtexture[10];
initialisetTabTexture();

//notre map
decors map[xmax][ymax];
initit_map();

...
//test collision
pour chaque case faire
   si map[x][y].estTraversable = false
         on traverse pas
    sinon
         on traverse
...

// affichage
pour chaque case faire
     sdl_blit(tabtexture[map[x][y].numTexture]);

Si t'as rien compris, que ca t'embrouille ou autre chose négative, soit j'suis bidon(fort possibl) , soit il te manque des notions et t'as besoin d'entrainement sur ces notions la.
Donc avant de continuer ton jeux , Relis le manuel/cours/tutoriel page:

• enum
• typedef
• structure
• variables

une fois bien saisi, repense à l'organisation de tes données et fais un choix.

Ok, merci beaucoup bugar, finalement j'ai compris, j'ai juste à transformer mon tableau int **map en decors **map et faire mes allocations avec sizeOf(decors*) et sizeOf(decors) comme taille quand j'avais des sizeOf int et int* . Creer une structure décors avec les champs qui m'intéresse (je pense faire un char[] nomTexture et un champ int typeDecors)
Mon incompréhension viens du fait que j'avais oublié comme était fait les tableaux de types structurés (comme les normaux en fait ), je pense que ne faire que coder depuis quelques temps m'a un peu fatigué et fait mélanger les notions

En tout cas merci énormément pour cette aide titanesque que tu m'as apportée et ce temps que tu as pris pour expliquer en détail

Petite curiosité, pour les enum, je fais un enum pour les différents objet (mur1, mur2, decors1, decors2, vide) et un pour les typedecors (mur, vide, decors) ou juste le premier (car au final c'est possible de faire juste le premier, mais est-ce que c'est propre comme code? et je ne peux pas mettre les mêmes nom dans les deux enum si?

je ne peux pas mettre les mêmes nom dans les deux enum si?
non et à l’intérieur les noms doivent etre distincts.

Petite curiosité, pour les enum, je fais un enum pour les différents objet (mur1, mur2, decors1, decors2, vide) et un pour les typedecors (mur, vide, decors) ou juste le premier (car au final c'est possible de faire juste le premier, mais est-ce que c'est propre comme code?

Tu fais en fonction de tes besoins et de ta vision des choses.
L'enum a l'avantage de facilité la lecture du code, plutôt que de lire des chiffres, tu lis des mots.
Tu peux très bien utiliser qu'une enum.

sinon je t'ai mis un commentaire à propos de ton saut et ta recuperation de touche, sur le forum programmation

bon finalement un enum suffira et c'est même plus clair ainsi

merci de me prévenir pour l'autre forum je n'avais pas vu, au final j'avais reglé le problème en recodant plus ou moins la fonction que tu me conseillais d'utiliser mais en application direct à mon programme