A propos des structures

Bonjour !

Après avoir bien avancé dans le développement de mon jeu, je me retrouve confronté à un nouveau problème.

Je vais essayer d'expliquer la situation au plus précis (et concis).

Le jeu tire au hasard une map (elle se dessine sur le background de la room), sur laquelle figure différents types de salle. Dans chaque salle, il y aura un pion (représenté par un Bouton de GUI). Ce pion déclenchera un événement lié au type de salle où il se trouve. A savoir, comme type de salle: garage, salon, cuisine, chambre, wc, rangement et bureau.

Selon la map, il peut y avoir 2 salles de type bureau, 1 salle de type garage, 4 salles de type cuisine... bref, c'est pas forcément 1 de chaque.

L'idée c'est que selon la map tirée (reconnue par sa sprite), une fonction place les pions d'événement sur les salles. Cela se fait au hasard, donc un pion a plusieurs possibilités. Voici la fonction que j'utilise (et qui marche) :

Code:

function Objectifs(int pion, int nombre, String type1, int xtype1, int ytype1, String type2, int xtype2, int ytype2, String type3, int xtype3, int ytype3, String type4, int xtype4, int ytype4)
{
  int o=Random(nombre-1);
  if (o==0)
  {
    obje[pion].type=type1;
    obje[pion].Bouton.Visible=true;
    obje[pion].Bouton.SetPosition(xtype1, ytype1);
  }
  if (o==1)
  {
    obje[pion].type=type2;
    obje[pion].Bouton.Visible=true;
    obje[pion].Bouton.SetPosition(xtype2, ytype2);
  }
  if (o==2)
  {
    obje[pion].type=type3;
    obje[pion].Bouton.Visible=true;
    obje[pion].Bouton.SetPosition(xtype3, ytype3);
  }
  if (o==3)
  {
    obje[pion].type=type4;
    obje[pion].Bouton.Visible=true;
    obje[pion].Bouton.SetPosition(xtype4, ytype4);
  }
}

Ainsi quand je fais appel à Objectifs(1, 2, garage, 300, 250, salon, 523, 612), je fais apparaître le premier bouton d'événement au hasard dans une pièce de type garage ou une pièce de type salon. Pour une même map, il y aura donc cette fonction Objectifs qui sera appellée X fois pour placer X pions événements. (jusqu'à 9 max).

Lorsqu'on clique sur ces boutons, cela tire au sort un événement lié au type de salle.

C'est pour ça que j'ai voulu créer une structure pour simplifier le script, et permettre d'ajouter facilement des types de salles supplémentaires si le jeu le nécessite, et aussi pour coder plus rapidement (et facilement) chaque map du jeu (sachant qu'il y en aura une centaine :S )

J'ai donc scripté une structure avec juste les paramètres voulus : un tableau Obje pour contenir les pions du GUI, un pointeur Bouton pour que l'index du tableau pointe vers un bouton du GUI, le type de salle du bouton sous forme de "string" (cette phrase sonne bizarrement pardon), et un numéro pour que l'on sache bien que Obje[1] correspond au pion 1 du GUI.

Malheureusement, je n'arrive pas du tout à faire fonctionner cela, je me retrouve généralement avec un null pointer referenced (alors que je les définis au début du jeu), et je crois que j'ai besoin de l'aide d'experts

Est-ce que j'utilise une méthode qui semble être la bonne pour ce que je veux faire ?

Je rappelle en simplifié ce que je cherche : un GUI avec 9 boutons que j'intègre à une structure dans un tableau, un pointeur pour chacun de ces boutons, une fonction qui les place au hasard selon la map tirée et une fonction "générique" qui lorsqu'on clique sur l'un de ces boutons, cela déclenche aléatoirement un événement en fonction du type de salle attribué au bouton cliqué (sous forme de String).

J'espère arriver à être clair, n'hésitez pas à me dire si ce que je raconte est un bazar sans nom

Il me semble y avoir beaucoup de choses dans ce que tu décris, et j'ai un peu de mal à me faire une idée précise de comment les choses doivent marcher, notamment en ce qui concerne la fonction Objectifs. J'imagine que tu l'appelles manuellement avec des paramètres différents pour chaque map quelque part dans ton script, probablement dans un grand if qui teste le numéro de sprite dessiné sur l'arrière-plan.
Et donc cette fonction attribue aléatoirement un type de salle au pion spécifié, parmi les quatre types passés en arguments de la fonction. Dans ton exemple tu donnes seulement deux types de salle à ta fonction (garage et salon), comment c'est censé fonctionner ? Aussi, est-ce qu'il y a une raison pour laquelle ta fonction gère 4 types de salle aléatoires alors que tu as une diversité plus importante de types de salle (7 pour le moment) ?
Enfin, en imaginant que tu as une map genre avec 2 garages et 2 bureaux, et en supposant que tu appelles Objectifs sur quatre pions avec les mêmes paramètres (à part pion évidemment) comment tu t'assures que l'assignation aléatoire se retrouve pas avec 3 ou même les 4 pions assignés au même type de salle, par exemple 4 garages (alors que la map n'en a que deux) ?

Tu pourrais aussi considérer définir des types énumérés persos plutôt qu'utiliser des strings pour les types, ça t'évitera le risque de faire des fautes de frappe et passer un temps fou à les déboguer.

Alors, au final tu avais très bien saisi comment ça fonctionne

Effectivement, la fonction Objectifs est appellée manuellement dans un grand IF qui teste le numéro de la sprite dessiné en arrière plan. Pas de problème là-dessus.

En gros, sur ce background (map tiré au hasard), il y a une trentaine de salles qui sont regroupées par lot de 2, 3 ou 4 par bâtiment. Dans chaque bâtiment il y aura un pion (bouton de GUI), c'est pour ça que c'est tiré au hasard : dans un bâtiment de 4 salles, il y a 4 possibilités de placement pour le pion, et donc 4 types de salles différents par bâtiment.

Ainsi, j'appelle la fonction Objectifs autant de fois qu'il y a de pions, et dans ses arguments, à chaque fois j'indique le nombre de possibilités pour chaque bâtiment.

En fait, au début j'avais fait quelque chose qui marchait du tonnerre, mais c'était scripté lourdement. J'avais 9 boutons de gui PAR type de salle et PAR numéro (garage de 1 à 9, salon de 1 à 9 etc... donc quasiment 80 boutons pour couvrir toutes les possibilités) et du coup je scriptais tout manuellement. Là l'idée c'est de trouver un moyen d'automatiser cela en ayant le moins de choses à écrire. Je suis obligé de coder chaque background manuellement, mais je suis pas obligé d'en faire un travail de forçat

Exemple de fonction pour une salle qui a 8 bâtiments avec différents nombres de salles :

Code:

if (carte[tirage] == 147) // le numéro de sprite du background
{  
  Objectifs(1, 4, bureau, 244, 164, wc, 328, 158, salon, 328, 244, chambre, 242, 244);
  Objectifs(2, 4, bureau, 424, 169, salon, 549, 169, rangement, 526, 249, rangement, 410, 249);
  Objectifs(3, 4, salon, 649, 168, wc, 762, 168, rangement, 787, 246, rangement, 664, 242);
  Objectifs(4, 3, bureau, 246, 460, rangement, 321, 460, wc, 401, 460);
  Objectifs(5, 3, cuisine, 512, 460, rangement, 639, 460, wc, 716, 460);
  Objectifs(6, 4, rangement, 650, 676, rangement, 761, 676, salon, 780, 753, wc, 662, 753);
  Objectifs(7, 3, garage, 575, 730, wc, 416, 777, bureau, 401, 688);
  Objectifs(8, 3, salon, 240, 730, chambre, 317, 685, cuisine, 317, 765);
// premier argument : le numéro du pion qui va être placé (de 1 à 9)
// deuxième argument : les possibilités du placement (de 1 à 4, jamais plus)
// ensuite le premier type de salle possible et les coordonnées du pion si c'est celui-ci qui est tiré
// ensuite le second type de salle possible et les coordonnées du pion si c'est celui-ci qui est tiré
// ensuite le troisième type de salle possible et les coordonnées du pion si c'est celui-ci qui est tiré
}

Ainsi, il n'y a aucun risque d'avoir 4 garages dans une map qui n'en a que 2, car à chaque fois je lui dis : là c'est un pion qui peut être garage, salon ou chambre, mais ici ce sera un pion entre salon, cuisine et wc....

Bref, c'est pour ça que je pensais passer par une structure. J'imaginais qu'en utilisant les string, on pourrait facilement rédiger le code de chaque map, et ce sera aussi plus lisible qu'avec genre des chiffres (genre chiffre 1 pour indiquer "salon", 2 pour indiquer "garage"???)

EDIT : par ailleurs, j'ai un problème de Null pointer referenced que je ne comprends pas.

Code:

function Objectif1_OnClick(GUIControl *control, MouseButton button)
{
  if (obje[1]!=null)
  {
    Display("Yes !");
  if (obje[1].type==garage) Objectif1.Prise_Objectif(1, 4); // le null pointer referenced est ici (et sans doute les lignes du dessous auront le même problème)
  if (obje[1].type==salon) Objectif1.Prise_Objectif(1, 1);
  if (obje[1].type==chambre) Objectif1.Prise_Objectif(1, 6);
  if (obje[1].type==cuisine) Objectif1.Prise_Objectif(1, 2);
  if (obje[1].type==rangement) Objectif1.Prise_Objectif(1, 7);
  if (obje[1].type==bureau) Objectif1.Prise_Objectif(1, 5);
  if (obje[1].type==wc) Objectif1.Prise_Objectif(1, 3);
  }
}

Les "garage", "salon" etc sont des String que j'ai crées et auxquelles le script a accès. obje[1] a été défini au game start, .type est une string définie dans la structure (elle est mise à jour avec la fonction Objectifs vue plus haut, en fonction du background), Objectif1 est le bouton de GUI qui est placé sur la map... :S

Ouf, ça y est j'ai réussi !

Alors en fait, c'était assez bête, mais c'est surtout grâce à toi Kitai ! Je connaissais pas les "enum", et en fait c'est juste génial. ça permet de manipuler des int comme si c'était des string, parce que les string ça semble plus complexe à gérer. Enfin tout devient plus lisible avec l'enum. Pas besoin de structure et de tout le bazar, j'ai réussi à m'en sortir.

Merci pour le coup de main !

Content d'avoir aidé

Par ailleurs KITAI, je vois dans ta signature que tu parles d'aider à la traduction du manuel en français. J'ai parfois relevé des erreurs dans le manuel de mon AGS 3.5, je peux te les faire remonter ?

C'est souvent des phrases anglaises qui traînent, ou des erreurs dans la traduction des scripts (genre "LeBouton" puis plus loin "TheButton").

Le manuel francophone en ligne est plus du tout à jour pour la version 3.5, donc ouais, y'a pas mal de boulot d'édition à faire

C'est un wiki public, tu peux éditer n'importe quelle page sans avoir à t'identifier