Tableaux dynamiques : des piles et des files

J'ai souvent eu besoin d'utiliser des tableaux dynamiques dans AGS. Seulement, les tableaux dynamiques que propose AGS ne sont pas assez "dynamiques" pour l'utilisation que j'en fais.
En effet, on peut créer un tableau d'une taille arbitraire avec AGS, mais une fois que ce tableau est créé, il n'y a aucune façon native d'agrandir ou de diminuer ce tableau sans l'effacer du même coup. En termes plus techniques, les tableaux dynamiques dans AGS ne sont ni des files, ni des piles.

Après plusieurs "reformulations", j'en suis arrivé à une petite fonction plutôt efficace pour agrandir les tableaux de façon vraiment dynamique :

Code:

/// Cette fonction retournera une copie du tableau auquel on aura ajouté VALEUR
int[] TableauAjouteInt(int tableau[], int taille, int valeur) {
  if (taille < 0) taille = 0;
  int tmp[] = new int[taille+1];
  int i = 0;
  while (i < taille) {
    tmp[i] = tableau[i];
    i++;
  }
  tmp[i] = valeur;
  return tmp;
}

Ensuite, il vous suffit d'agrandir un tableau de la façon suivante :

Code:

int taille = 2; // TAILLE sera la taille du tableau dynamique
int tableau[] = new int[taille]; // Création d'un tableau
tableau[0] = 10; // Assignation de valeurs arbitraires
tableau[1] = 20; // aux 2 premières cases
tableau = TableauAjouteInt(tableau, taille, 30); // Ajout de 30 à la fin du tableau
taille++; // On vient d'ajouter une valeur : on incrémente TAILLE
Display("> %d", tableau[2]); // Affichera "> 30"

Maintenant, vous pouvez aussi coder des fonctions pour traiter ces tableaux comme des piles ou des files :

Code:

/// Cette fonction retournera une copie du tableau dont on aura supprimé la dernière (si PILE vaut true) ou la première (si PILE vaut false) valeur
int[] TableauPopInt(tableau[], taille, bool pile) {
  if (taille <= 1) return null;
  int tmp[] = new int[taille-1];
  if (pile) {
    int i = 0;
    while (i < taille-1) {
      tmp[i] = tableau[i];
      i++;
    }
    return tableau;
  }
  else {
    int i = 1;
    while (i < taille) {
      tmp[i-1] = tableau[i];
      i++;
    }
    return tableau;
  }
}

Ensuite, vous utilisez ça comme ça :

Code:

//    Pile
int taille_pile = 2; // TAILLE_PILE sera la taille de la pile
int pile[] = new int[taille_pile]; // Création d'une pile
pile[0] = 10; // Assignation de valeurs arbitraires
pile[1] = 20; // aux 2 premières cases
Display("> %d", pile[taille_pile-1]); // Affiche "> 20"
pile = TableauPopInt(pile, taille_pile, true); // Supprime le dernier élément de la pile
taille--; // Réduction de la taille de 1
Display("> %d", pile[taille_pile-1]); // Affiche "> 10"

//    File
int taille_file = 2; // TAILLE_FILE sera la taille de la file
int file[] = new int[taille_file]; // Création d'une pile
file[0] = 10; // Assignation de valeurs arbitraires
file[1] = 20; // aux 2 premières cases
Display("> %d", file[0]); // Affiche "> 10"
pile = TableauPopInt(pile, taille, false); // Supprime le premier élément de la pile
taille--; // Réduction de la taille de 1
Display("> %d", file[0]); // Affiche "> 20"

Un exemple d'utilisation :

Code:

int taille_file;
int[] file;

function on_key_press(int touche) {
  // Chaque fois que le joueur appuie sur une touche autre que Retour, on ajoute son code à la file
  if (touche != eKeyReturn) {
    file = TableauAjouteInt(file, taille_file, touche);
    taille_file++;
  }
  // Si le joueur appuie sur Retour, on affiche dans l'ordre les touches sur lesquelles il a appuyées
  else {
    while (taille_file > 0) {
      Display("Touche %d", file[0]);
      file = TableauPopInt(file, taille_file, false); // FALSE : on traite bien file comme une file
      taille_file--;
    }
    // La file est maintenant vide
  }
}

Pratique, les tableaux dynamiques ! Et les piles m'ouvrent des perspectives fascinantes...
Merci pour l'astuce.

Je me permets d'éditer le premier message pour mettre à jour le lien "ni des piles, ni des files" qui était mort et qui me semble correspondre à cette page-ci.

J'en profite pour poser une question : est-il possible (sans rendre le système beaucoup plus complexe car ça touche déjà les limites de mes compétences) de créer un système de pile mais qui, au lieu de supprimer la dernière entrée du tableau, supprimerait n'importe quelle entrée, faisant "tomber" les entrées suivantes pour boucher le trou ? Dans l'exemple d'une pile de pièce, cela reviendrait à retirer la pile de rang n, et toutes les pièces de rang n' où n' > n se retrouveraient au rang n' - 1.

Dans mon cas se rapprochant plus d'un tableau à double entrée, il faudrait en plus appliquer ce système à un grand nombre (enfin plus de 10) de piles en même temps.

Oui bien sûr c'est tout à fait possible, en fait ce serait probablement plus intelligent d'avoir quelque chose comme ça  (code non testé) :

Code:

/// Cette fonction retournera une copie du tableau dans lequel on aura inséré VALEUR à INDEX
int[] TableauInsereInt(int tableau[], int taille, int valeur, int index) {
    if (taille < 0) taille = 0;
    if (index < 0) index = taille + index;
    // Si toujours inférieur à zéro, on n'a qu'à prendre le premier
    if (index < 0) index = 0;
    if (index > taille) index = taille;
    int tmp[] = new int[taille+1];
    int i = 0, j = 0;
    while (i < taille) {
        if (j==index)
            tmp[j] = valeur;
            j++;
        }
        tmp[j] = tableau[i];
        i++;
        j++;
    }
    if (index==taille)
        tmp[taille] = valeur;
    return tmp;
}

/// Cette fonction retournera une copie du tableau dont on aura supprimé la valeur à INDEX
int[] TableauRetireInt(tableau[], taille, int index) {
    if (taille <= 1) return null;
    if (index < 0) index = taille - index;
    // Si toujours inférieur à zéro, on n'a qu'à prendre le premier
    if (index < 0) index = 0;
    if (index >= taille) index = taille-1;
    int tmp[] = new int[taille-1];
    int i = 0, j = 0;
    while (j < taille-1) {
        if (i == index) i++;
        tmp[j] = tableau[i];
        i++;
        j++;
    }
    return tmp; // Correction :  tableau >> tmp
}

// Dans l'en-tête
import int[] TableauInsereInt(int tableau[], int taille, int valeur, int index = -1); // -1 > ajoute à la fin par défaut (pile)
import int[] TableauRetireInt(int tableau[], int taille, int index = 0); // 0 > retire du début par défaut (file)

Merci pour cette version alternative.

Je me permet de rapporter une petite erreur  :
Edit : Bon en fait je dis n'importe quoi, j'étais fatigué.

En revanche, ça marche bien des centaines de fois et parfois il y a une boucle infinie dont je ne parviens pas à identifier la cause... C'est fâcheux.

Je sais pas pour ton problème de boucle infinie (qu'est-ce qui te fait dire que c'est ça en particulier ? t'as un message d'erreur d'AGS ?) mais pour la fonction de retrait il me semble que ça devrait retourner tmp plutôt que tableau (j'ai corrigé le message plus haut en conséquence)

Ah oui y'avait cette erreur là aussi, j'avais oublié de la signaler.

Pour le while, y'a un système qui fait qu'AGS crash au delà de 150000 boucles (pour éviter que ça reste figé) mais ce qui est vraiment étrange c'est que j'ai codé un message d'erreur perso à 149000 boucles, et il n'est pas appelé avant... Du coup je me demande si c'est pas AGS qui déconne. Si c'est le cas je tenterai d'ajouter un noloopcheck pour pas que le nombre de boucles soit limitées (mais laisser mon erreur personnalisée du coup) et voir ce qui se passe.

C'est possible qu'il y ait pas une boucle while en particulier qui dépasse la limite, mais si tu appelles la fonction qui contient cette boucle plusieurs fois à partir d'une autre fonction (à plus forte raison, à partir d'une autre boucle while) alors AGS peut détecter ça comme un dépassement du nombre limite de cycles
Du coup si tu décides d'utiliser noloopcheck, préfixe aussi ta fonction mère, pas seulement tes fonctions d'insertion et retrait de tableaux

J'ai pensé aussi ça avec une hypothèse légèrement différente, que ce qui serait comptabilisé seraient toutes les boucles while du cycle en cours, mais même avec cette hypothèse ça me paraît impossible d'atteindre 150000 dans les cas concernés... En tout cas depuis que j'ai ajouté le mot clé noloopcheck (uniquement dans les fonctions d'insertion et retrait de tableaux ) je n'ai plus rencontré ce problème jusqu'à maintenant.

Je recommanderais donc à de futurs utilisateurs de ces superbes fonctions de faire de même et d'éventuellement ajouter un message d'erreur personnalisé AbortGame à l'intérieur des boucles s'ils veulent éviter que le jeu freeze en cas de problème.

Coucou,


Alors, je ne comprends pas bien le terme de file et pile ; mais si j'ai bien tout capté, l'idée c'est de pouvoir créer un tableau et de pouvoir changer sa valeur lorsqu'on veut ?
Ça demande beaucoup de ressource au moteur de garder des "cases" de tableau actives inutilement ? Pour un souci de perf,  toujours, car gagner des FPS c'est devenu mon nouveau cheval de bataille...

Est-ce que ça fonctionnerait avec les Structures ?

Exemple :
Là où ça pourrait être cool comme code, ça serait pour générer des coffres aléatoirement, par exemple.

Code:

Struct Coffre {

int level;
int Nbr_object;
int Case[Nbr_object];
String obj_description[Nbr_object];

}

imaginons, au début du jeu, je voudrais qu'il y ait que 10 coffres.

Code:

int ini_nbr_coffre = 10;

Coffre coffre[ini_nbr_coffre];

Avec ta fonction, je pourrais par exemple créer une fonction.

Code:

function Ajout_Coffre( int Level, int Object_nombre  ) {

ini_nbr_coffre++;

TableauInsereInt(coffre, ini_nbr_coffre, 0, 0);

coffre[ini_nbr_coffre].level = Level;

if( Level == 1)
{
              for (int i = 0; i < Object_nombre ; i++) {
        
                 int r = Random(4);

                 if( r == 0)        coffre[ini_nbr_coffre].Case[i] = iPain.ID;
                 if( r == 1)        coffre[ini_nbr_coffre].Case[i] = iCouteau_Rouille.ID;
                 if( r == 2)        coffre[ini_nbr_coffre].Case[i] = iSlip.ID;
                 if( r == 3)        coffre[ini_nbr_coffre].Case[i] = iBouclier_bois.ID;
              
                  coffre[ini_nbr_coffre].obj_description[i] = inventory[coffre[ini_nbr_coffre].Case[i]].GetTextProperty("Description");
             }

}

if( Level == 10)
{
              for (int i = 0; i < Object_nombre ; i++) {
        
                 int r = Random(4);

                 if( r == 0)        coffre[ini_nbr_coffre].Case[i] = iBrioche.ID;
                 if( r == 1)        coffre[ini_nbr_coffre].Case[i] = iCouteau_Or.ID;
                 if( r == 2)        coffre[ini_nbr_coffre].Case[i] = iArmure_Or.ID;
                 if( r == 3)        coffre[ini_nbr_coffre].Case[i] = iBouclier_Or.ID;
          
         coffre[ini_nbr_coffre].obj_description[i] = inventory[coffre[ini_nbr_coffre].Case[i]].GetTextProperty("Description");
             }

}

//etc...

}

filoulefilou a écrit:

l'idée c'est de pouvoir créer un tableau et de pouvoir changer sa valeur lorsqu'on veut ?

Oui, et plus précisément, c'est pouvoir insérer ou retirer des entrées à un point précis de ce tableau.

On parle de pile lorsqu'on ajoute toujours les nouveaux éléments à la fin du tableau et qu'on récupère aussi en priorité les éléments à la fin du tableau (donc ceux ajoutés le plus récemment, comme dans une pile d'assiettes si tu veux). On parle de file lorsque, comme pour les piles, on ajoute toujours les nouveaux éléments à la fin, mais on récupère en priorité les éléments qui se trouvent au début (donc ceux ajoutés le plus tôt, comme dans une file d'attente si tu veux).

filoulefilou a écrit:

Ça demande beaucoup de ressource au moteur de garder des "cases" de tableau actives inutilement ? Pour un souci de perf,  toujours, car gagner des FPS c'est devenu mon nouveau cheval de bataille...

Ça va dépendre de beaucoup de paramètres, en particulier de la taille de ton tableau, du type de données de ton tableau, et de la fréquence à laquelle tu fais des opérations dessus. Dans la plupart des cas, la solution optimale consiste à recycler les cases inactives (s'il y en a) lorsque tu ajoutes un nouvel élément.

filoulefilou a écrit:

Est-ce que ça fonctionnerait avec les Structures ?

Il y a des limites dans AGS pour l'instant, l'une d'elles étant que tu peux seulement avoir des tableaux de taille prédéfinie avec les structs. Tout l'intérêt des piles et des files consiste à manipuler des tableaux de taille indéfinie, ou plutôt dynamiquement redéfinie durant l'exécution du programme. Donc tu peux pas avoir des piles et des files de struct. Par contre tu peux avoir des structs qui contiennent des piles/files (lesquelles ne peuvent évidemment pas elles-mêmes être de type struct, uniquement int/bool/String/etc).

Donc malheureusement non, l'idée dans ton exemple ne marchera pas. Il existe une sorte d'astuce documentée sur une page que valoulef m'a partagée (j'ai perdu le lien par contre) pour avoir un truc très proche de ça en utilisant le mot-clé manage et en recréant tout le système de tableaux dynamiques à la main, mais comme tu peux probablement déjà deviner c'est assez complexe et pas certain que ça vaille le coup de constuire une usine à gaz dans ton cas particulier de coffres.

Kitai a écrit:

Il existe une sorte d'astuce documentée sur une page que valoulef m'a partagée (j'ai perdu le lien par contre) pour avoir un truc très proche de ça en utilisant le mot-clé manage et en recréant tout le système de tableaux dynamiques à la main

Il doit s'agir de cette page.

Attention ! Des int ont été oubliés dans la déclaration de paramètres de la dernière version, pour la fonction TableauRetireInt. Voici la version corrigée :

Code:

/// Cette fonction retournera une copie du tableau dans lequel on aura inséré VALEUR à INDEX
int[] TableauInsereInt(int tableau[], int taille, int valeur, int index) {
    if (taille < 0) taille = 0;
    if (index < 0) index = taille + index;
    // Si toujours inférieur à zéro, on n'a qu'à prendre le premier
    if (index < 0) index = 0;
    if (index > taille) index = taille;
    int tmp[] = new int[taille+1];
    int i = 0, j = 0;
    while (i < taille) {
        if (j==index)
            tmp[j] = valeur;
            j++;
        }
        tmp[j] = tableau[i];
        i++;
        j++;
    }
    if (index==taille)
        tmp[taille] = valeur;
    return tmp;
}

/// Cette fonction retournera une copie du tableau dont on aura supprimé la valeur à INDEX
int[] TableauRetireInt(int tableau[], int taille, int index) {
    if (taille <= 1) return null;
    if (index < 0) index = taille - index;
    // Si toujours inférieur à zéro, on n'a qu'à prendre le premier
    if (index < 0) index = 0;
    if (index >= taille) index = taille-1;
    int tmp[] = new int[taille-1];
    int i = 0, j = 0;
    while (j < taille-1) {
        if (i == index) i++;
        tmp[j] = tableau[i];
        i++;
        j++;
    }
    return tmp; // Correction :  tableau >> tmp
}

// Dans l'en-tête
import int[] TableauInsereInt(int tableau[], int taille, int valeur, int index = -1); // -1 > ajoute à la fin par défaut (pile)
import int[] TableauRetireInt(int tableau[], int taille, int index = 0); // 0 > retire du début par défaut (file)

D'ailleurs peut-être serait-il utile de mettre une copie de cette version dans le premier message du topic ?

Bonjour !

Alors j'ai l'impression que cette fonction de tableau dynamique encore plus dynamique pourrait m'aider. Est-ce que quelqu'un pourrait me donner un coup de main à l'utiliser ?

J'ai créé un sujet avec ma problématique, je planche dessus, mais là je cale...

La situation est grosso modo que j'ai deux tableaux dynamiques de personnages (characters) : un qui gère les personnages présents dans une room, l'autre qui gère les personnages présents dans une autre room. Ces tableaux permettent, via des fonctions, de placer les personnages alignés en bas de la room (dans l'ordre, sans qu'ils se marchent dessus).

L'idée c'est qu'un certain nombre de persos est en room 6 (la base), que certains d'entre eux vont en room 7 (l'expedition), et qu'ils reviennent ensuite en room 6. Il y a donc une sorte d'échange entre ces tableaux, et le nombre de personnages peut varier (entre ceux qui meurent ou ceux qui rejoignent l'équipe...).

Du coup, réaliser cela est encore bien flou pour moi.

Si quelqu'un veut bien me venir en aide, le lien vers mon sujet où tout est expliqué :

https://adventuregamestudio.1fr1.net/t3050p150-lancer-son-premier-jeu#46934

D'avance merci !!

Je suis pas sûr que tu aies besoin d'un tableau dynamique, puisque tu utilises une constante MAXPERSOSEXPEDITION. Tu peux mettre ça en haut de ton script :

Code:

Character* persoscolonie[MAXPERSOSEXPEDITION];
Character* persosexpedition[MAXPERSOSEXPEDITION];

Ensuite si tu veux t'assurer qu'un perso se trouve dans colonie mais pas dans expédition, tu peux faire ça :

Code:

Character* perso = character[2];
bool dejaDansColonie = false;
int indexLibre = -1;
for (int i = 0; i < MAXPERSOSEXPEDITION; i++) {
  if (persoscolonie[i] == perso) dejaDansColonie = true;
  if (persosexpedition[i] == perso) persosexpedition[i] = null;
  if (persoscolonie[i] == null) indexLibre = i;
}
if (!dejaDansColonie && indexLibre >= 0) persoscolonie[indexLibre] = perso;

Une méthode encore plus simple serait de définir MAXPERSOSEXPEDITION au nombre total de personnages dans ton jeu, et toujours utiliser l'index 2 dans persoscolonie et persosexpedition pour représenter le personnage 2 (par exemple)

Ah, intéressant !

Ce qui veut dire que j'oublie les 2 constantes pour n'en avoir plus qu'une seule : MAXPERSOS (qui est égale au nombre total de persos dans le jeu)

que mes deux tableaux ont une taille égale à MAXPERSOS

et que je donne à chaque personnage du jeu une place prédéfinie dans les tableaux ?

Cela impliquerait qu'au lieu de les enlever des tableaux, je leur donne juste une valeur "null" ?

exemple : dans les tableaux persoscolonie et persosexpedition :
- character[1] à l'index 1, character[2] à l'index 2, character [3] à l'index 3 etc... jusqu'à 50 s'il y a 50 personnages.
- puis dans mes boucles, je scanne tous les personnages, et s'ils sont pas là, je leur donne une valeur "null" ?

EDIT : j'ai bien besoin d'une aide détaillée si vous avez le courage, parce que je ne comprends plus trop ce que je dois faire... Si besoin, je peux réexpliquer la situation en détails pour que vous puissiez comprendre au mieux. Peut-être que mes posts sont incompréhensibles à force d'écrire et de chercher...

EDIT 2 : je crois que ça marche !!!!! En fait, avant de lancer les boucles j'avais bien réinitialisé les tableaux persoscolonie et persosexpedition, mais... j'avais pas réinitialisé les indexpersoscolonie et indexpersosexpedition ! D'où les placements bizarres... Bon je fais des tests plus poussés et je vous tiens au courant si c'était une fausse lueur d'espoir