TUTO Créer un inventaire en PAWN !

Coucou les amis aujourd'hui on va créer un inventaire !
Dans ce tuto je m'occuperai juste de la partie script de l'inventaire et non de l'affichage que je vous laisse libre de faire (chose aisée si vous comprendrez ce que nous allons faire ci-dessous !).
Je tiens à préciser que je reviens vite sur les notions de base de pawno et que pour pouvoir bien comprendre

Commençons par le commencement !
Créons une variable qui va permettre de recenser l'inventaire du joueur :

Code:

#define Rien 0 // Ici on définit l'ID de l'item qui va nous permettre de dire qu'il y a rien
#define MaxPlaces 10   // On définit ici le nombre de places maximales que l'inventaire peut comporter
enum params {            // Cette énumération va permettre de définir l'ID de l'item (car il faudra évidemment le répertorier) ainsi que le nombre de cet item.
      Item,
      Number
};
new PlayerInventory[MAX_PLAYERS][MaxPlaces][params];  // Enfin la variable à 3 dimensions qui permettra de gérer tout ça !

Si nous créions quelques fonctions qui pourraient nous être utiles dans le futur ? Comme savoir si l'inventaire est plein etc...
On peut déjà créer des fonctions assez simples pour débuter comme savoir si une case de l'inventaire est vide ou pas :

Code:

stock IsCaseEmpty(playerid, id)  // On stockera la fonction nous permettant ainsi de ne pas avoir de warnings quand on ne l'utilise pas. Fonction à 2 paramètres : playerid , un entier  et id un autre entier !
{
       if(PlayerInventory[playerid][id][Item] == Rien && PlayerInventory[playerid][id][Nombre] == 0) return true;  // Si l'item de la case est égal à Rien et que son nombre est nul alors on retournera la valeur vraie ! (Il faudra penser à
bien remettre à zéro le nombre de la case quand vous viderez un objet d'une case d'inventaire, auquel cas vous vous exposez à un chamboule-tout !
       else return false;  // Dans le cas contraire, la case sera occupée d'un objet différent de Rien et ne sera donc pas vide, on retournera la valeur fausse !
}

Une fonction assez simple qui vous permettra de poursuivre dans des fonctions un tchiot peu plus complexes n'est-ce-point.
Comme par exemple savoir si l'Inventaire est plein, s'il ne l'est pas : retourner la première case qui est vide :

Code:

stock IsInventoryFull(playerid) // Pareil que pour tout à l'heure sauf que là on inspecte tout l'inventaire on aura donc pas besoin du second paramètre "id"
{
        new value = -1;  // Ici cette variable va contenir la valeur que retournera la fonction, soit -1 pour l'inventaire plein ou alors une certaine valeur de la première case vide pour l'inventaire pas plein | On l'initialise à -1, partons
du principe que l'inventaire soit plein, si cette valeur ne change pas au cours de notre boucle ci-dessous, alors l'inventaire est plein !
        for(new i=0; i < MaxPlaces ; i++) // Ici c'est une boucle que l'on va faire tourner MaxPlaces fois (ici ce sera 10 fois) et à chaque tour on rajoutera +1 à la valeur précédente de i
        {
                 if(IsCaseEmpty(playerid,i)) // Oh saperlipopette on retrouve notre fonction de tout à l'heure. Oui ! On va vérifier chaque case, une par une, si elle est vide ou pas ...
                 {
                         value = i;  // .... auquel cas on retournera l'id de la première case vide
                        break; // Et évidemment on stoppe la boucle car on veut la première case vide et non pas la dernière, ainsi avec break ça empêchera que ça retourne !
                 }
        }
        return value; // Ayant fait notre analyse avec la boucle, on va pouvoir retourner le résultat des courses, libre à vous d'interpréter la valeur de cette variable en retournant un message Inventaire plein ou pas
}

Une tchiote dernière fonction pour la route ? Toujours avec une boucle, qui vous permettra de retirer un item de l'inventaire du joueur :

Code:

stock RemoveItem(playerid, item, number) //  Différents paramètres : playerid (vous savez) , item (id de l'item répertorié, pour l'instant nous n'avons que l'item Rien ! Vous pouvez en créer après  ) et number (pour le nombre que
vous souhaitez retirer)
{
        for(new i=0; i < MaxPlaces; i++) // Encore et toujours une boucle, parce qu'on ne s'en lasse jamais ! (Je ne vous réexplique pas la boucle, c'est le même principe que pour les fonctions précédentes)
        {
                  if(PlayerInventory[playerid][i][Item] == item)  // Ca fait longtemps qu'on l'a plus recroisée cette variable ! Nous allons chercher dans quelle case l'ID d'item correspond à celui fourni par la fonction
                  {
                              PlayerInventory[playerid][i][Number] -= number;  // Si il y a une égalité d'ID item dans votre inventaire, alors la case concernée se verra retirer la valeur entrée dans la fonction
                              if(PlayerInventory[playerid][i][Nombre] < 0) // Pour éviter les nombres négatifs on va tout régler ci-dessous !
                              {
                                          PlayerInventory[playerid][i][Item] = 0; // Ainsi si le nombre de l'item entré est égal à 0, alors il n'en a plus et donc il a Rien en item
                                          PlayerInventory[playerid][i][Number] = 0; // Par ailleurs, le nombre de Rien est égal à 0 également
                              }
                  }
        }
}

Bon voilà on a quelques fonctions, sauf une fonction essentielle (promis c'est la dernière après on peut passer aux commandes !) ; à savoir le don d'objets !

Code:

#define Eau 1 // Définissons quelques items d'objets (pareil que pour l'Item Rien  )
#define Pain 2
#define Herbe 3

stock HasAlreadyItem(playerid, item) // Fonction que j'avais zappé pour savoir si le joueur a déjà un item dans son inventaire qui retournera -1 si non, si oui elle retournera la valeur de la case
{
        new value; // Valeur que retournera la fonction
   for(new i;i < MaxPlaces; i++) // Encore et toujours la même boucle
   {
       if(PlayerInventory[playerid][i][Item] == item) // Cherchons les cases où l'ID d'item est le même que celui recherché
      {
          value = i; // Si oui value prend la valeur de cette case
          break; // Et bien entendu on arrête la boucle car sinon elle tournera sans utilité
      }
      else value = -1; // Si non alors elle retournera -1
   }
   return value; // Et évidemment on oublie pas de retourner cette valeur
}

stock GiveObject(playerid, item, number) // Ici ça va être en quelque sorte la fonction inverse de RemoveItem
{
        if(HasAlreadyItem(playerid,item) == -1 && IsInventoryFull(playerid) == -1) return SendClientMessage(playerid,0,"L'inventaire est plein comme une bombonne"); // Si le joueur n'a pas déjà cet item et qu'il n'y a plus de cases vides, alors NON !
        else
        new value; // Ici value prendra la valeur de la case où l'on pourra mettre l'objet
        if(HasAlreadyItem(playerid,item) != -1)  value = HasAlreadyItem(playerid);  // Si le joueur a déjà cet item, alors value prendra la valeur que doit retourner la fonction
        else value = IsInventoryFull(playerid); // Sinon value prendra la valeur de la première case libre
        if(number > 0)  // Pour un nombre d'objet positif (donc un ajout d'objet) on aura ça
        {
                  PlayerInventory[playerid][value][Item] = item; // Ainsi l'ID d'item de la case value prendra pour valeur l'item souhaité
                  PlayerInventory[playerid][value][Number] += number; // Et son nombre augmentera de la valeur number
        }
        else RemoveItem(playerid, item, floatround(floatabs(float(number)))); // Cependant pour un nombre d'objet négatif (donc un retrait) il faudra retirer une valeur positive et non pas négative, pour cela on va passer le nombre en float (pour qu'il puisse être traité par
les outils mathématiques) puis on le repassera en entier.
        switch(item) // Optons pour rajouter des messages informant le joueur, ici on va chercher les valeurs que prend item
        {
                    case 1 : SendClientMessage(playerid,1,"Tu as reçu de l'eau"); // Dans le cas où item = 1
                    case 2 : SendClientMessage(playerid,1,"Tu as reçu du pain");  // item = 2
                    case 3 : SendClientMessage(playerid,1,"Tu as reçu de l'herbe"); // item = 3
                    default : SendClientMessage(playerid,1,"Tu n'as rien reçu parce que t'es laid"); // Et dans tous les autres cas différents de ceux du dessus
          }
      return 1;
}                   
       

Comme je vous l'ai dit vous pouvez afficher à votre guise l'inventaire au joueur (soit sous forme de dialogs, de textes, de textdraws ou que sais-je encore).
Allez nous on va opter pour le dialog :

Code:

   if(strcmp(cmdtext,"/inventaire",true)==0)
   {
      new msg[1024];
      for(new i; i < MaxPlaces ; i++) // un air de déjà vu, ici on va afficher ligne une par une correspondant à chaque case
      {
          new string[256];
         format(string,sizeof(string),"{ff0000}%d (Nombre] {ffffff}%d (Item)\n",PlayerInventory[playerid][i][Nombre],PlayerInventory[playerid][i][Item]); // Formatons la chaine de texte pour y insérer les valeurs de chaque variable
         strcat(msg,string); // strcat, vous permettra d'ajouter une chaine de texte à la précédente chaine de texte
      }
      ShowPlayerDialog(playerid,1,DIALOG_STYLE_MSGBOX,"Inventaire",msg,"Ok",""); // Affichons le dialogue !
      return 1;
   }


Libre à vous de remplacer l'ID des items par des noms plus significatifs !
Sur ce, je pense que c'est la fin de ce tuto, j'espère qu'il vous aura permis d'apprendre, revoir, découvrir d'autres horizons de pawno.
Etant mon premier vrai tuto, pouvez-vous me dire si ça a été assez explicite, les points à améliorer etc... je suis ouvert aux critiques !

Il y aussi le tutoriel de Pix : 
https://www.gtaonline.net/forums/index.php?topic=17413.0

Le tutoriel de Pix permet de traiter un seul objet dans l'inventaire. Il n'y a aucune notion de boucles qui y apparaissent (du moins pas pour le traitement d'objets).
Qui plus est, il s'oriente plus sur la gestion de textdraw en coordination avec les variables de l'inventaire contrairement à moi.

"Il y a aussi" je n'incinue pas que celui de Pix remplacera le tien, c'est juste un exemple ^^

Merci du partage !

Merci du partage !

Est-ce qu'il faut définir chaque ID d'objet avec #define en haut du GM ?

Nan t'es pas obligé, quand j'ai fait ça j'ai pas visé l'optimisation mais tu peux faire sous forme d'un tableau dans lequel tu stockerais toutes les informations de chaque objet, exemple :

Code:

#define MAX_OBJETS 3
enum InfoObj
{
  NomObjet[32],
  Valeur
  // Dans l'énumération tu mets les informations que tu souhaites concernant l'objet
};
new ObjetInfo[MAX_OBJETS][InfoObj] =
{
  {"Rien", 0},
  {"Redbull", 15},
  {"Voiturette", 123}
};



Avec cette démarche-là ce sera plus simple d'automatiser tous tes objets que tu as créés et tu t'y retrouveras mieux.
Quant à l'ID d'objet ce sera ni plus ni moins que l'index de la première dimension du tableau (0 pour Rien,  1 pour Redbull, 2 pour Voiturette).

whawhahwahwah trop complexe pour moi