Bonsoir,

Pour un jeu de Sokoban, je cherche à faire un tableau à deux niveaux asymétrique en fonction de la résolution que la personne aura choisit.

int grille[x][y];

Lorsque je déclare le tableau dans une fonction, j'indique la taille du tableau en déclarant la deuxième valeur.

void fontionTruc(grille[][y])
{
  print quelque chose;
}

le tableau change du coup en fonction des préférences.

Si x < y je me retrouve avec plein de case vide
Si x > y je me retrouve avec un overflow.

Je peux faire un fonction pour prendre la plus grand comme valeur.

int max(int x, int y){
    if (x < y){
    return y;}
    else{
    return x;
    }
}

Du coup, je crée un tableau symétrique

int grille[max()][max()];

Mais si x = 4y, j'utilises 4 fois plus de mémoire que nécessaire.
 
Donc ma question est comment en créer un asymétrique pour limiter l'utilisation de la mémoire ?

Est ce possible ?
Est ce que je fais fausse route?

Cordialement,
Kao

-
Edité par kao_chen 23 septembre 2016 à 23:11:43

kao_chen a écrit:

Donc ma question est comment en créer un asymétrique pour limiter l'utilisation de la mémoire ?

Quel est le cahier des charges concernant cette limitation mémoire ?

Par contre je n'ai pas tout compris, mieux vaut donner un exemple de ce que tu souhaites faire algorithmiquement, ou par un exemple d'application simple et visuel.

Bonjour,

Pour commencer → «Règles de ce forum, à lire avant de poster», histoire de savoir utiliser le bouton </> pour insérer le code …

Ensuite → crée un tableau dynamique

typedef struct {
  size_t x;
  size_t y;
  type_machin **data;
} sokoban_t;

Merci pour vos remarques je veux essayer d'être plus clair.

J'utilise un tableau pour avoir des coordonnées x/y afin de me repérer dans mon jeu de Sokoban.

A chaque coordonnées j'affecte une structure pour stocker différentes valeurs, les manipuler et les relires plus tard.

typedef struct
{
  int mainRole;           
  int subRole;           
  int goalRole;           
  int boxRole;         
  int playerRole; 
} Square

Pour déterminer la taille du tableau, j'utilise une fonction qui prends la plus grande valeur entre une hauteur "h" et une largeur "w"

int max(int h, int w){
    if (h < w){
    return w;}
    else{
    return h;
    }
}

J'initie ensuite le tableau au démarrage de l'application :

int h = 20, w = 30;  
int max = max (h,w);
Square grid[max][max];

 int x = 0, y = 0;
    for(y = 0; y < max; y++)
     {
        for(x = 0; x < max; x++)
           {
               grid[x][y].mainRole = GROUND;
               grid[x][y].subRole = EMPTY;
               grid[x][y].goalRole = EMPTY;
               grid[x][y].boxRole = EMPTY;
               grid[x][y].playerRole = EMPTY;

           }
     }

Ce système fonctionne parceque je fabrique un tableau symétrique même si x est différent de y.

Mais je voudrais fabriquer un tableau de ce type

Square grid[h][w];

 Sans passer par la fonction max() afin d'être au plus juste, et de ne charger que la partie utile dans le tableau.

En espérant avoir été plus clair.

J'ai publié l'intégralité de mon code ici : https://github.com/kaochen/SokoRobot

Mais comme je débute c'est loin d'être propre, j'utilises ce projet justement pour apprendre et progresser.

Cordialement,

Kao

Tu devrais simplement relire un cours sur les tableaux …

Écrire :

Square grid[h][w];

void grid_init(size_t h, size_t w, Square grid[h][w])
{
  for(size_t x=0; x<h; ++x)
    for(size_t y=0; y<w; ++y)
      grid[x][y] = (Square) {.main=GROUND. .sub=EMPTY, .goal=EMPTY, .box=EMPTY, .player=EMPTY };
}

est tout à fait valide … tu te compliques la vie car tu ne maitrises pas les tableaux.

OK, je vais méditer ça, et me replonger dans les tableaux, merci pour l'info.