Lancer son premier jeu

Je vois deux solutions, soit tu identifies les cartes via leur sprite (je rappelle que carte[0] renvoie le sprite de la carte concernée (qui ne change jamais)). Donc tu peux faire quelque chose comme :

Code:

if (carte[tirage] == 14){
//ton code
}

Sinon tu peux utiliser aussi la propriété "Delay" de chaque carte pour leur attribuer un code spécifique (ce qui te permettrait d'attribuer le même code à deux cartes qui doivent avoir le même comportement si jamais ça t'es utile).
Quoi qu'il en soit si tu veux vraiment un comportement spécifique à chaque carte, il va falloir le coder manuellement pour chaque carte (mais bon ça tu t'en doutes).

Une solution pour organiser ça proprement, ce serait de faire une fonction personnalisée où tu liste le le comportement des cartes. Comme ça :

Code:

function BoutonsCartes (int IDcarte) {
if (IDcarte == 0) //ton code
else if (IDcarte == 1) //ton code
//etc
}

Ensuite tu peux mettre ça où tu veux :

Code:

BoutonsCartes(carte[0]);

Qui exécutera le code désiré en fonction de la valeur de "carte[0]" (mais tu peux remplacer ça par n'importe quelle autre variable). Ce n'est pas obligatoire mais ça te permet de coder le comportement de tes cartes à un endroit déterminé pour clarifier ton code, et aussi tu peux faire appel à la fonction depuis différents endroits.

Ah super alors ! Donc c'est effectivement via le numéro de sprite qu'on va pouvoir les identifier. Cela veut-il dire que carte[0] = sprite 0 ? J'espère pas...

Parce que dans la ligne que tu as écrite : if carte[tirage] == 14, ça veut dire "si la carte qui vient d'être tirée  est la carte dont le sprite est le numéro 14" ?

A priori, chaque carte aura son comportement spécifique. Et oui, je me prépare mentalement à coder des centaines de cartes... Mais notre ami "copier coller" va être d'une grande aide pour adoucir ce labeur

EDIT : j'avais pas vu ton "edit" Mais du coup, je suis pas sûr d'avoir pigé...

Baguettator a écrit:

Cela veut-il dire que carte[0] = sprite 0 ? J'espère pas...

Bah non, le sprite c'est celui qui s'affiche quand tu tires la carte.

Baguettator a écrit:

Parce que dans la ligne que tu as écrite : if carte[tirage] == 14, ça veut dire "si la carte qui vient d'être tirée  est la carte dont le sprite est le numéro 14" ?

Oui, du coup. Et ça peut tout aussi bien être la carte 0, 4, 8 ou que sais-je.

En gros ce que j'ai mis après c'est que tu peux créer une fonction dans le GlobalScript que tu pourras utiliser où tu veux après, exactement comme on l'a fait avec "TableauRetireInt". C'est un ensemble de lignes de code que tu pourras appeler simplement en écrivant le nom de la fonction, et dans les parenthèses, les paramètres que tu auras déclarés avec la fonction (int IDcarte, dans mon exemple).

Cool, merciiiii !

Bon je vais tester ça dans les jours qui viennent ! Pour l'instant je suis bien occupé à créer les sprites, à préparer les images avec la bonne résolution, en tout joli... C'est passionnant, sans ironie !

Bonjour !

Je suis en train de programmer des menus de sélection de personnages avant de programmer ce qu'on a vu précédemment pour les cartes (à savoir, les choses spécifiques qui apparaissent selon telle ou telle carte qui a été choisie...).

Je me demande si c'est possible de faire en sorte que le jeu se bloque tant que le joueur appuie pas sur un bouton. J'ai testé la fonction "PauseGame" mais j'ai pas l'impression que c'est ce qui me convient. Par exemple, le joueur arrive dans la room "sélection des personnages", et après le fade in, un message apparaît, lui disant : "sélectionnez vos personnages". J'aimerai que le joueur ne puisse cliquer sur rien d'autre que le bouton pour fermer ce message. Un peu comme quand on fait pause dans un jeu, on voit en arrière plan l'image du jeu arrêté au moment où on a fait pause, mais on peut pas intéragir avec sans avoir fermé le menu "pause".

J'ai l'impression, au flair, qu'une solution serait de scripter les boutons dont on ne veut pas qu'ils soient actifs lorsque le message apparaît, de cette manière :

Code:

function Bouton_on_click (......)
If Game is Paused
(laisser vide pour signifier que ça ne fait rien si le jeu est en pause)
else
(faire l'action du bouton)

Mais il y a peut-être une autre solution ? Plus économique ?

Re-bonjour !

ça y est, je me lance, après avoir passé de nombreuses heures à préparer la sélection des personnages (qui marche bien maintenant !), je m'occupe des programmations de chaque carte !

Alors, de ce que tu m'as expliqué précédemment, j'ai compris ceci :

- après le tirage de la carte (qui se fait en room 7, la room où la carte doit apparaître, et elle se fait avant le fadein), je rentre le code suivant :

Code:

if carte[tirage] == 12 // si la carte tirée est la carte dont le sprite est le numéro 12
// je fais apparaître tel bouton à tel endroit, tel gui à tel endroit etc...
if carte[tirage] == 15 // si la carte tirée est la carte dont le sprite est le numéro 15
// je fais apparaître tel truc à tel endroit etc...
[...]
// et ainsi de suite pour toutes les cartes que j'aurai intégrées au jeu

ça veut dire des milliers de ligne de code, mais je retrousse les manches

Pour organiser ça mieux avec la fonction que tu m'as présentée (Boutonscartes), je ne sais pas à quel point ça "clarifie" le code. J'ai juste l'impression qu'au lieu de coder chaque carte dans le script de la room 7, je dois le faire dans le global script ?

Dans mon cas, ça voudrait dire que dans mon global script, je mets :

Code:

   

        function BoutonsCartes (int IDcarte) {
        if (IDcarte == 0) //mon code concernant la carte dont le sprite est 0
        else if (IDcarte == 1) //mon code concernant la carte dont le sprite est 1
        //etc pour toutes les cartes intégrées au jeu
        }

Puis dans la room 7, je réappelle la fonction après le tirage de la carte :

Code:

if (carte[tirage] == 0) {
BoutonsCartes(carte[0])
}
if (carte[tirage] == 1) {
BoutonsCartes(carte[1])
}

Est-ce que c'est bien cela ? A adapter avec le numéro des sprites (qui ne sera sans doute pas "continu", car comme je n'ajoute pas les cartes les unes après les autres, leurs ID peuvent être 1, 5, 6, 10, 12, 152, 153 etc... mais peu importe tant qu'on s'y retrouve j'imagine !)

EDIT : pour l'instant, j'ai réussi à faire fonctionner comme je le veux ! J'ai dû décaler les lignes de codes qui retirent une ligne du tableau (celle de la carte qui vient d'être piochée) et les mettre tout en bas de la fonction "room_load". Si la ligne du tableau était retirée avant le code qui concerne la carte tirée, ça faisait crasher le jeu. Voici le code actuel de ma room 7 (j'ai juste demandé que lorsque la carte[tirage] est celle dont le sprite est le numéro 145, cela fait apparaître un bouton à tel endroit, et le fait disparaître lorsqu'on quitte la room) :

Code:

// room script file


function room_Load()
{
  gAffichageexpedition.Visible=true;
  Niveaudangerbleu.Visible=false;
  Exit.Visible=false;
  Objectif.Visible=false;
 int tirage = Random(nbCartes - 1); //Si on a 9 cartes, alors on veut obtenir une valeur entre 0 et 8.
    DrawingSurface* surface = Room.GetDrawingSurfaceForBackground(); //On crée une surface de dessin nommée "surface" contenant l'arrière plan de la room.
    surface.DrawImage(0, 0, carte[tirage]); //On dessine au coordonnées x = 0, y = 0, le sprite correspondant à la carte qu'on vient de tirer
    surface.Release(); //On indique qu'on a fini de dessiner et on met à jour le nouvel arrière plan.
 
   
    // on y va, on code les cartes !
if (carte[tirage] == 145)
{
  Niveaudangerbleu.SetPosition(1060, 90);
  Niveaudangerbleu.Visible=true;
}
 carte = TableauRetireInt(carte, nbCartes, tirage);
    nbCartes--; //On n'oublie pas de mettre à jour le nombre de cartes
}

function room_Leave()
{
  Niveaudangerbleu.Visible=false;
gAffichageexpedition.Visible=false;

}

Dans mon test, les cartes tirées disparaissent bien, et le bouton apparaissait au bon moment !! Hourra !

C'est pas du tout obligatoire de créer une fonction, si ça te convient de le faire comme ça alors tout va bien. Ceci dit l'idée n'était pas d'appeler la fonction pour chaque carte (sinon pour le coup ça sert vraiment à rien) mais de faire uniquement :

Code:

BoutonsCartes(tirage)

Mais si tu n'as pas d'intérêt particulier à le faire alors tu peux oublier ça pour le moment.
Je n'ai pas encore trop creusé le sujet sur ta question de blocage des boutons, j'essaierai d'y penser.

Hello !

Effectivement, j'y ai bien réfléchi, dans le sens où il y a tellement de paramètres que j'ai envie de personnaliser pour chaque carte que je crois que ça ne vaut pas le coup de faire une fonction. mais ça aurait été top pour automatiser les choses si elles avaient besoin de l'être ! Par exemple, si chaque carte du jeu a 9 objectifs à placer, ça aurait permis d'économiser un peu de lignes de codes en automatisant l'apparition des objectifs. En rappellant la fonction, on aurait juste précisé l'emplacement des objectifs (qui reste spécifique à chaque carte), et du coup ça aurait été plus simple.

Mais dans mon cas, le nombre d'objectifs est différent chaque fois, le placement aussi, et y a encore d'autres paramètres... Bon j'ai décidé de faire du copier coller d'un code complet d'une carte (avec tous les paramètres) et de l'ajuster à chaque carte. Peut-être que dans quelques temps, je vais le regretter, ou alors j'aurais de l'artrose

Au sujet des boutons qui sont bloqués, j'ai l'impression qu'on pourrait faire :

Code:

Bouton_onclick
If (IsGamePaused())
{
// peut-être ici mettre Bouton.enabled=false; mais je sais pas si ça marche, en tout cas laisser vide doit revenir au même
}
else
// les actions à faire quand le bouton fonctionne

Mais je crois que j'ai trouvé plus simple : lorsque je fais apparaître un bouton et que je veux que ce bouton "éteigne" les autres (comme un menu pause), je fais que ce bouton est placé sur un fond transparent de la taille de la room. Comme ça le clique ne passe pas à travers l'image transparente, qui est posée au-dessus. En tout cas, moi ça marche, et ça ne rajoute pas une ligne de code

Alors, nouvelle interrogation : est-ce qu'il est possible de faire apparaître un GUI en fonction de son ID ?

Parce que j'ai implémenté un système d'événements qui sont générés aléatoirement pendant le jeu. Et je voudrais que lorsque le joueur clique sur un objectif (qui sera un bouton, mais peu importe), cela fasse apparaître un événement de manière aléatoire. Donc faire quelque chose d'à peu près similaire que ce qu'on a fait avec nos cartes, mais le faire avec des GUI.

En effet je peux pas utiliser le "Draw.Surface" (je sais plus le nom exact de cette fonction) car l'événement doit apparaître, dire "blablabla son texte blablabla", puis on clique sur OK et le texte de l'événement disparaît. On voit à nouveau la carte qui est en train d'être jouée.

Par exemple, si mes événements sont dans les GUIS 9 à 28, je pourrai faire un tirage aléatoire entre ces GUI là (du genre Random(19)+9, ça ferait une valeur entre 9 et 28). Mais je ne sais pas si c'est possible.

De plus, impossible d'envisager de changer de Room...
Si vraiment y a pas de solution, ben je coderai tout à la main

EDIT : éventuellement, je pourrai faire le tirage au sort parmi des boutons plutôt que parmi des GUI (je peux faire apparaître un GUI puis tirer au sort quel bouton de ce GUI apparaîtra, pour faire apparaître le message d'un événement au hasard)

EDIT 2 : j'ai trouvé ça sur le forum anglosaxon de AGS, et si j'ai bien compris ça devrait résoudre mes questions, je pense !

https://www.adventuregamestudio.co.uk/forums/index.php?topic=48759.0

Oui bien sûr tu peux faire ça mais ça veut dire passer par plus de lignes de code. Je pensais qu'on pouvait faire :

Code:

GUI[0].Visible = true;

Mais apparemment non, ce qui est fort dommage. Du coup je sais pas ce qu'il y a comme solution pour faire ça de la sorte.

Si tu passe par un texte aléatoire dans le code, pourquoi ne pas utiliser Display plutôt qu'un GUI ?

Le mot-clé GUI, tout en majuscules, est un constructeur de classe. Il faut utiliser le mot-clé gui, tout en minuscules, qui est un tableau qui référence les différentes instances de la classe GUI.

EDIT : je viens de remarquer les edits de @Baguettator -- les deux mot-clés sont illustrés dans un code sur le sujet en lien, sur le forum anglophone

Kitai a écrit:

Le mot-clé GUI, tout en majuscules, est un constructeur de classe. Il faut utiliser le mot-clé gui, tout en minuscules, qui est un tableau qui référence les différentes instances de la classe GUI.

Arf, j'avais essayé "GUI" et "Gui" mais je n'ai pas pensé à "gui". Merci @Kitai !

Super, merci pour vos réponses !! Content que cela puisse se faire !!

Cela veut-il dire que c'est aussi faisable avec des boutons ? Par exemple, rassembler des événements aléatoires d'un même "type" (par exemple, ceux qui donnent de la nourriture) dans un seul GUI, créer ensuite un bouton pour chaque événement, puis faire le tirage au sort parmi ces boutons ?

En effet, je viens de regarder, les boutons de GUI ont un "ID". Mais je ne sais pas comment l'utiliser. On dirait que l'ID du bouton est "dépendant" du GUI auquel il appartient, car il est grisé (on ne peut pas le modifier), et l'ID est attribué en fonction de l'ordre de création (le premier qu'on crée a ID 0, puis 1, 2 etc...).

Vous savez s'il y a une fonction qui permette d'utiliser l'ID de ces boutons ?

Ce que j'aimerai faire, c'est grosso modo quelque chose comme (en supposant d'avance que les GUI en question ont le même nombre de boutons) :

Code:

objectif=Random(2);
if (objectif == 0)
{
gNourriture.Visible=true;
tirageboutons=Random(2) + 1; // pour pas sélectionner le bouton 0 qui est un bouton de menu.
button[tirageboutons].Visible=true; // le bouton dont l'ID est égal à tirageboutons apparaît.
}
if (objectif == 1)
{
gCarburant.Visible=true;
tirageboutons=Random(2) + 1;
button[tirageboutons].Visible=true;
}
if (objectif == 2)
{
gMunitions.Visible=true;
tirageboutons=Random(2) + 1;
button[tirageboutons].Visible=true;
}

J'imagine qu'il faudra un moyen de faire identifier au jeu que c'est les boutons du GUI concerné qu'il faut tirer au sort...

Si vous connaissez une fonction qui permette de faire ce genre de choses, ça peut m'éviter de nombreuses lignes de code...

Tu peux parcourir Controls dans ton GUI et retenir uniquement ceux qui sont des boutons, et après tu en tires un au hasard. Par exemple (code non testé) :

Code:

Button* tireBoutonGUI(GUI* monGui) {
  Button* boutons = new Button[monGui.ControlCount];
  int nombreBoutons = 0;
  for (int n = 0; n < monGui.ControlCount; n++){
    GUIControl *control = monGui.Controls[n];
    if (control.AsButton != null) {
      boutons[nombreBoutons] = control.AsButton;
      nombreBoutons++;
    }
  }
  return boutons[Random(nombreBoutons-1)];
}

Whaoo, c'est dingue, ce qu'on peut faire avec ce logiciel...

Après réflexion, j'ai pu faire fonctionner ça, mais j'ai choisi de faire .BringToFront() à l'évenement qui a été choisi (ils sont tous de même taille et centré au même endroit dans le GUI) plutôt que de faire un tirage au sort parmi les boutons (il y aura d'autres boutons dans le GUI...). Cela me permet d'avoir un suivi de "l'effet de l'evenement" grâce à des variables. ça fait des lignes de code, mais ça marche, et je ne sais pas s'il y a un meilleur moyen... Pour l'instant ça fait très bien l'affaire

Merci pour l'aide !

J'en viens maintenant à ce qui sera peut-être le plus dur : la gestion des personnages.

Dans mon jeu (et je rappelle que c'est un logiciel qui permet de jouer à un jeu de société avec un nouveau mode de jeu, une sorte de "mode campagne", plus immersif. Le logiciel agit comme une interface pour les joueurs), on choisit 6 personnages pour les joueurs, puis 6 personnages pour l'équipe adverse (contrôlée par l'ordi). Puis au cours de la partie, il arrivera sans doute que certains meurent, d'autres arrivent, et cela dans les deux camps.

Je me dis que je vais sans doute avoir besoin que ces personnages soient des "character" dans AGS pour plusieurs raisons :

- bien qu'ils soient immobiles, je pense utiliser leurs "frames" pour changer leur apparence quand par exemple ils sont blessés ou malades : quand ils sont normaux, frame 1, blessés => frame 2, malades => frame 3, mort => frame 4 etc... Donc il faudra pouvoir passer d'une frame à une autre, au moyen par exemple d'un bouton qui lui sera attaché (reste à savoir comment faire que le bouton soit toujours placé à côté du personnage...?)

- ils auront sans doute un inventaire, mais est-ce qu'un inventaire peut avoir une taille limitée ? Ou même mieux, la taille de l'inventaire peut-elle être gérée par un paramètre ? Par exemple : nbemplacementinventaire = score_confort * 2;

- le seul problème : si les personnages sont des character, j'ai peur que ce soit compliqué de les afficher "proprement" à l'écran. Dans mon cas, alignés en bas. Si l'un d'eux meurt, les autres se décalent pour "combler" le vide. Ce genre de choses, à automatiser (je voudrais pas que les joueurs aient à y toucher), ça me semble pas évident à faire. J'ai imaginé un système de "Imiter un click à l'endroit x, y et s'il n'y a rien faire bouger à x, y", mais je sens que c'est une impasse...

Mais j'ai une autre piste de réflexion : est-ce que ces personnages ne pourraient pas être des "objets d'inventaire" ? Cela permettrait de les faire apparaître dans un "inventaire" qui pourrait être situé au bas de l'écran. Et cet inventaire aurai par exemple 6 emplacements au début, et lorsqu'on trouve un septième personnage, l'inventaire gagne un emplacement supplémentaire. A l'inverse, si l'un meurt, un emplacement disparaît. Pour rendre compte de leur état (malade, mort, blessé...), peut-être que les objets peuvent changer de Sprite ? Je ne sais pas si ce genre de choses sont possibles ?

Bon, j'avoue que cela est assez confus et flou, j'ai la tête explosée à force de chercher une solution à ça et à éplucher les aides AGS en ligne

Mais si vous avez déjà des petites suggestions sur les idées ci-dessus, je suis preneur !

Alors, ce matin, j'ai les idées plus claires, et j'ai peut-être trouvé un bout de réponse à mes problèmes !

Par avance, désolé de poster plusieurs messages à la suite, des fois je suis si fatigué de lire des pavés de messages de forums ou d'aides en ligne que je passe à côté des infos importantes...

J'ai l'impression que pour ce que je veux faire, le plus simple serait que les personnages du jeu soient des objets d'inventaire.

Mon jeu se présente ainsi (je ne note que ce qui concerne les personnages) :

- room 1 : menu principal (new game, load game, options etc...)

- room 2 : choix des personnages (50 disponibles, il faut en choisir 6 pour les joueurs humains et 6 pour l'équipe adverse de l'ordinateur)

- room 3 : c'est l'écran principal du jeu qui correspond à la "base" des joueurs humains. En bas s'affichent les personnages qu'ils ont choisis. A partir de cet écran, le joueur choisit les personnages qui partiront en "expedition" (ce qui revient à tirer une carte au hasard, comme vous m'avez aidé à faire le système de pioche aléatoire)

- room 4 : c'est l'expédition, la carte s'affiche. Les personnages du joueur sont affichés en bas. Si des personnages de l'équipe adverse doivent apparaître dans le jeu, ils sont affichés en bas à droite. Une fois que l'expedition est terminée, on retourne en room 3.

Du coup, pour ce que je veux faire, j'imagine que je peux créer un personnage qui s'appelle "basejoueur", un personnage qui s'appelle "expeditionjoueur" et un personnage qui s'appelle "expeditionadverse". Ces personnages sont invisible (car pas besoin d'intéragir avec eux) mais possèdent un inventaire respectif :

- basejoueur a en inventaire les personnages possédés par le joueur
- baseadverse a en inventaire les personnages possédés par l'équipe adverse
- expeditionjoueur a en inventaire les personnages sélectionnés pour partir en expedition
- expeditionadverse a en inventaire les personnages adverses qui interviendront pendant l'expédition.

Grâce à ça, j'imagine qu'il suffit de faire que :

- une fois qu'on a choisi les persos (6 pour joueur, 6 pour adverses), dans la room 3, on ajoute à l'inventaire de "basejoueur" les persos sélectionnés, et de même pour "baseadverse"
- lorsqu'on part en expédition, on choisit les persos qui partent, on les retire de l'inventaire de "basejoueur" et on les ajoute à l'inventaire de "expeditionjoueur"
- si jamais durant l'expedition on trouve d'autres persos qui rejoignent l'équipe, on les ajoute à l'inventaire "expeditionjoueur"
- lorsqu'on revient d'expedition, on retire les persos de "expeditionjoueur" et on les ajoute à "basejoueur"

Bon, je pense que ça c'est faisable ! Après, j'ai vu qu'on peut animer les objets, en utilisant des vues et des loops. Je peux utiliser ce système pour représenter l'état des personnages :
- si perso en pleine santé : l'objet est avec la "standing view"
- si perso malade : l'objet est animé en continue avec la loop 1 (apparaît une image du personnage avec un petit symbole malade)
- si perso blessé : l'objet est animé en continue avec la loop 2 (apparaît une image du personnage avec un petit symbole "blessé")

J'aimerai faire un système où sous chaque personnage il y a un petit bouton qui permet de changer son état : un bouton qui le "blesse", un bouton qui le rend "malade". Peut-être que ces boutons peuvent apparaître avec quelque chose du genre :
if expeditionjoueur "a le personnage michael dans l'inventaire"
alors "faire apparaître les boutons concernant le personnage michael aux coordonnées (x, y)"
// avec (x, y) les coordonnées de l'objet "michael". En espérant qu'un objet dans un inventaire possède des coordonnées qu'on peut repérer !!

Le seul problème, c'est si le perso est blessé ET malade. Ou si le perso est blessé 3 fois, dans ce cas il meure. ça voudrait dire que si on appuie trois fois sur le bouton blessure. Il faut peut-être faire que si l'objet est déjà blessé, si on appuie sur le bouton "malade", il s'anime avec une loops qui fait apparaître une image qui montre ses deux états (malade et blessé). J'imagine que ça doit être possible. Je vais chercher.

Bon, j'ai pas encore testé tout ça, mais vous pensez que c'est faisable ce genre de choses ? Ou y aurait-il d'autres moyens pour le réaliser ?

Salut,
Quand tu parles d’objets à animer, je crois que tu confonds avec les objets qui sont relatifs aux rooms, pour un inventaire on parle d’item et du coup je ne suis pas certain qu’AGS permette nativement d’animer des items à partir d'une view et d'une loop. Par contre il est possible de changer la propriété graphic d'un item directement avec le numéro d’un sprite, donc en bricolant un peu tu peux les animer assez facilement.

Une autre approche serait d’utiliser un gui avec des boutons non interactifs pour afficher tes personnages (les boutons peuvent être animés avec des loops).
Ou même d'utiliser des characters en gérant leurs positions à l’écran dynamiquement par un script.
Si tu te sens limité par toutes les autres solutions tu peux aussi envisager de créer ta propre interface avec un overlay et des sprites dynamiques.

Hello,

Merci pour ta réponse ! Effectivement, j'ai dû confondre entre "objets" et "items"... :S

La bonne nouvelle, c'est que je ne veux pas vraiment les "animer" (faire enchaîner plusieurs images pour leur donner du mouvement) mais juste changer leur "apparence" en fonction de l'état de santé du perso (donc de l'item qui le représente, en l'occurence).

Pour le GUI, j'y ai pensé, mais j'ai peur d'une chose : comment faire que tel perso soit ici, puis l'autre à côté etc... Surtout quand l'un d'eux meurt (ça veut dire décaler les autres pour combler le vide) ou quand d'autres arrivent (ça veut dire les mettre à la suite sans qu'ils empiètent l'un sur l'autre). J'ai l'impression qu'il faudrait attribuer à chaque perso une propriété (wanda est le personnage  qui s'affiche dans la première case, amy est le perso 2 qui s'affiche dans la case 2, phil est le perso 3 dans la case 3, si michael arrive dans l'équipe, il devient le perso 4 dans la case 4, et si amy meurt, phil passe dans la case 2 et michael dans la case 3...). Et pour ce genre de choses, j'ai peur que ce soit difficilement réalisable...

Idem si les persos sont des character, leur positionnement sera difficile à gérer. Du moins, c'est mon intuition de débutant dans AGS

Pour l'overlay, je vais regarder un peu ce que c'est, pour l'instant je n'en ai aucune idée !

C'est pour ça que j'ai pensé aux objets (et donc, en fait, aux items), car ils se rangent "à la suite" dans l'inventaire, et l'inventaire s'adapte au nombre d'item à l'intérieur.

Le plus compliqué sera aussi de faire que des boutons soient bien positionnés sous le personnage concerné, de sorte que quand je veux dire au jeu que Wanda a subi une blessure, je clique sur l'icone "blessure" sous wanda, et son apparence change pour représenter wanda blessée.

J'avoue que je ne vois pas encore de solution idéale ou réalisable, même si j'ai bon espoir avec les items... Je croise les doigts, car ça va être décisif sur les possibilités du jeu !

EDIT : c'est vrai que si tout ça est faisable avec des characters, ça peut être vraiment top ! peut-être mieux qu'avec autre chose

Pour gérer les positions des images des personnages dans des boutons, ou des characters sur ton écran, ou de dessiner des sprites sur la surface d’un overlay, la méthode est sensiblement la même que celle que tu as mise en place pour tes cartes il me semble.
Tu as besoin d’une liste sous la forme d’un tableau dynamique ou tu ajoutes et supprimes des éléments. Ta fonction d’affichage a ensuite besoin de lire cette liste et d’utiliser l’ordre des éléments pour la mettre à jour.
C’est ce que fait l’inventaire avec ses items en interne, mais effectivement c’est peut être plus simple d’utiliser ta méthode d’inventaire si elle te convient car il vaut mieux partir du plus simple avant de complexifier. C'est en bidouillant qu'on apprend le mieux !

Pour trouver les bonnes positions pour afficher tes boutons par rapport aux items tu devras certainement utiliser la fonction GetAtScreenXY des items pour les repérer.

Ah ouais ! Effectivement, j'avais pas fait le rapprochement, mais ça semble être la même méthode que pour la sélection des cartes ! Merci pour le coup de pouce !

Du coup, à vrai dire, il y a peut-être une solution intermédiaire à tout cela en combinant deux choses :

- les personnages sont représentés par des "items" placés dans des inventaires

- l'état de santé des personnages est représenté par des calques overlay (en espérant que j'aie bien compris de quoi il s'agit !). Lorsqu'on clique sur le bouton "blessure" de wanda car elle a subit une blessure, ça fait apparaître une sprite sur l'overlay au niveau de l'item "wanda". Cette sprite serait de la même taille que l'image de l'item wanda, mais avec seulement une petite goutte de sang dans le coin en bas à gauche (par exemple), le reste serait transparent. Comme ça, cette sprite "blessure" se pose sur l'image de Wanda, on voit donc wanda comme avant MAIS avec une petite goutte de sang dans le coin en bas à gauche, ce qui indique qu'elle est blessée ! On peut même mémoriser cette blessure dans une variable, comme ça la prochaine fois qu'on appuie sur le bouton blessure, une deuxième goutte de sang apparaît, et la troisième fois qu'on appuie sur le bouton, l'image de wanda est écrasée par un calque opaque d'une tête de mort car elle est morte !

- l'avantage de cette méthode serait que du coup les boutons sont liés en permanence à leur "item" (fonction GetAtScreenXY qui prend leurs coordonnées non stop), donc même si le joueur bouge les items dans les cases de l'inventaire, les boutons suivront !

- l'utilisation des calques permettrait de superposer autant d'états de santé que l'on veut : wanda peut être malade, blessée deux fois, et avec un bonus de combat, elle aura juste 4 calques superposés à son image, les calques seront conçus pour ne jamais empiéter les uns sur les autres, donc plus besoin d'utiliser des loops ou autres trucs compliqués ! ça veut peut-être juste dire qu'il faut créer plein de calques... Et bien savoir comment les enlever une fois l'expédition terminée ! Ou au contraire, conserver les calques sur wanda entre la room d'expedition et la room de la base, pour qu'on continue de voir que wanda, blessée lors de l'expédition, l'est toujours lorsqu'on rentre à la base (malgré le fait que l'item "wanda" aura changé d'inventaire, il sera passé de "expeditionjoueur" à "basejoueur").

Je suis en train de fantasmer sur un truc irréalisable, ou au contraire, c'est peut-être la solution ?

Une bonne solution serait de créer un Sprite dynamique, c’est à dire de définir une surface de la taille de ton item où tu dessines plusieurs sprites pour ton personnage et ses bonus/malus à des positions prédéfinies et selon les variables du personnage. Ensuite tu utilises ce Sprite comme Graphic de ton item et tu laisses tomber tous les calques d’overlay.
Quand j’avais programmé Les survivants, j’ai utilisé des ListBox sur mes items d’inventaire pour leur donner des ordres spécifiques (manger, jeter, donner…). La solution des boutons marche aussi, il faut que tu expérimentes.

Ah, idée intéressante ! Je viens de lire l'aide sur les sprites dynamiques.

ça voudrait dire qu'au lancement du jeu, je crée les sprites dynamiques pour chaque personnage ?
Et lorsqu'un personnage intègre une équipe (ce qui revient à dire que l'item représentant ce personnage arrive dans l'inventaire de la base par exemple), cet item s'affiche comme le sprite dynamique qui lui correspond ?

J'avoue que j'ai du mal à me lancer là-dedans car je n'ai pas encore manipulé ces choses-là, si l'un de vous peut me donner une piste de démarrage...

EDIT : pour les Listbox, merci du conseil, ça a l'air top ! Les boutons sont peut-être plus élégants, mais plus difficiles à mettre en place. Je verrai ça après, mais là je galère pour le dynamic sprite...

Il faut dessiner ton sprite dynamique au début, puis à chaque fois que tu as un changement d'état.
Pour l'image d'un item tu devrais avoir quelque chose dans ce style

Code:

DynamicSprite *spritePersonnage;

void DrawSprite(this InventoryItem*)
{
    DrawingSurface *surface ;
    spritePersonnage =  DynamicSprite.Create(LARGEUR_ITEM, HAUTEUR_ITEM); // Utilise la taille prédéfinie de tes items
    surface = spritePersonnage.GetDrawingSurface();
    surface.Clear(COULEURDEFOND); // pour mettre un fond coloré si besoin
    surface.DrawImage(POSITION_X, POSITION_Y, SPRITE_SLOT); // pour dessiner une 1ere image
    surface.DrawImage(POSITION_X, POSITION_Y, SPRITE_SLOT); // pour dessiner un autre image
    // etc sous condition des variables du personnage
    surface.Release();
    this.Graphic = sprite.Graphic;
}

que tu mets à jour en appelant

Code:

item.DrawSprite();

Après je ne sais pas comment tu gères tes personnages et leurs variables... Tu peux décider de faire une fonction DrawSprite pour chaque personnage avec des variables locales ou des propriétés personnalisées. Le plus propre serait peut être de créer une structure Personnage pour tout regrouper et l'utiliser en argument de ta fonction pour pouvoir appeler directement

Code:

item.DrawSprite(Wanda);

Merci pour l'aide ! J'y vois plus clair, je n'ai jamais utilisé cette fonction, et l'aborder est pour l'instant un peu rude pour moi

Arlann a écrit:

Après je ne sais pas comment tu gères tes personnages et leurs variables...

Les personnages ont plusieurs états possibles : bonne santé, malade, blessé, infecté, mort.
Effectivement je pourrais rendre compte de leur état avec une (ou des) variable(s). Par exemple pour le perso wanda : etatwanda. Si etatwanda==0, wanda est morte. Si etatwanda==1, wanda est en bonne santé. Et ainsi de suite. Peut-être avec plusieurs variables cela sera plus pratique.

L'idée est que si wanda est blessée, son "apparence" le montre. Et idem pour chaque état. Si elle meure, elle est retirée de l'inventaire.

Il faudrait que ces "états" puissent être enregistrés avec le menu de sauvegarde (que j'ai créé pour le jeu).

Quand tu dis "Le plus propre serait peut être de créer une structure Personnage pour tout regrouper et l'utiliser en argument de ta fonction pour pouvoir appeler directement", je ne te suis plus... :S

Je vais donner un cadre :

- 3 personnages : amy, wanda et phil. Ce sont des "objets d'inventaire" (iAmy, iWanda et iPhil). Leur sprite "de base" est une image de 90*130. Il y a leur visage qui occupe 90*110, la partie inférieure (dimmensions 90*20) servivrait à afficher leurs bonus/malus (si pleine santé : rien. Si blessé : une goutte de sang. Si malade : une fiole verte).

- sous chacun d'eux, un bouton pour donner au personnage l'état "blessé", un bouton pour donner l'état "malade".

ça voudrait dire que lorsque je clique sur le bouton "blessé" de phil, je demande au jeu qu'il dessine une sprite de "goutte de sang" dans la zone 90*20 de la sprite de l'objet "Phil" ?

Si je veux enlever la blessure, je supprime la sprite rajoutée ?

Oulaaaa... Je m'y perds... Vraiment désolé de ne pas comprendre !!!

Ne t’excuse pas de ne pas comprendre, si tu débutes complètement en développement c’est normal que ce soit « rude » et je ne suis pas un très bon formateur.
La difficulté c’est que j’essaye de comprendre ton besoin pour y apporter une solution qui me parait adaptée. Cela dit il y a d’autres approches pour arriver à faire ce que tu veux, des solutions plus simples à mettre en oeuvre que l’utilisation de Sprites dynamiques et de structures.  

C’est évident qu’il faut toujours partir du plus simple pour avoir des résultats rapidement et ne pas perdre en motivation. Je ne voulais pas te perdre et surtout pas te décourager. Si tu sens que mon approche n’est pas la bonne pour toi il faut faire différemment.

Le problème lorsqu’on utilise un moteur comme AGS c’est que l’on peut être limité par les fonctions qu’il propose de base. Pour sans détacher il faut réussir à les contourner ou à les utiliser différemment. C’est ce que tu fais en utilisant l’inventaire pour afficher des personnages, ce n’est pas prévu pour ça, mais si cela répond à tes besoins de game design rien ne l’interdit. Par contre cela va demander de bricoler un peu pour construire ton interface à ta façon. L’idéal est quand même de bien connaitre l’usage normal de toutes les fonctions existantes dans AGS pour ensuite les modifier, c’est pour cela qu’il est souvent conseillé de commencer par des petits projets de P N’ C, mais il n’y a pas d’obligation.

Voici plus d’explications :

L’idée du Sprite dynamique c’est de composer une image à partir de plusieurs images. Tu utilises donc l’image de base du personnage puis d’autres images pour représenter ses états que tu positionnes où tu veux sur l’image (tu peux aussi préparer des sprites de la bonne dimension et positionner les éléments en utilisant une couche alpha sur un logiciel de dessin, pour ensuite les afficher les uns sur les autres comme des calques sans trop t’embêter avec les positions).
A chaque fois que tu as besoin de changer l’état du perso, son image se re-dessine entièrement en suivant l’ordre de tes calques avec des conditions (if) de variables booléennes (true/false)
- le fond (facultatif)
- le perso (toujours)
- un bonus (si la condition est remplie)
- un malus (idem)
- une goutte de sang (idem)
-… (tu peux aussi afficher du texte, faire des cercles de couleurs et autres primitives…)
Ton Sprite est ensuite enregistré et utilisé comme image de ton item d’inventaire.
Donc si tu enlèves une blessure tu dessines tout depuis le début mais sans la blessure.

C’est une solution polyvalente mais il y a beaucoup plus simple car tu pourrais dessiner autant de Sprites qu’il existe d’états pour un personnage sur ton logiciel de dessin et choisir le Sprite à afficher en temps voulu. Tout dépend du nombre de combinaisons d’états dont tu as besoin…

Tu peux aussi utiliser les éléments que propose les GUIs pour composer ton interface en activant/désactivant des boutons qui servent d’images ou des labels pour afficher du textes. De la même façon je ne sais pas jusqu’à combien d’éléments tu vas vouloir afficher et cela peut devenir fastidieux de gérer beaucoup d’éléments de gui. Et il y a certainement une limite imposée par AGS.

Il y a sans doute d’autres solutions possibles peut être que d'autres pourront t'aider. Je te conseille d’aller au plus simple pour commencer et d’y aller progressivement.

En ce qui concerne les variables de tes personnages le raisonnement est le même, il y a plusieurs approches plus ou moins complexes selon tes besoins. Le plus simple pour commencer est de créer autant de variables que de personnages.
Effectivement tu peux utiliser une int par personnage (etatwanda==0) si quelques chiffres suffisent à couvrir la totalité des combinaisons d’états. Tu peux aussi choisir d’utiliser des booléennes  pour chaque état (bonus, blessure, mort…) pour avoir beaucoup de combinaisons possibles en restant lisible. Le problème c’est qu’avec beaucoup de personnages tu multiplies le nombre de variables et que si en cours de dev tu décides d’en modifier une tu peux te retrouver face à une montagne…

La structure dont je parle sert à imiter le comportement de la programmation orienté objet en construisant une classe de personnage qui contient toutes les variables et plus encore. Il suffit ensuite d’instancié un nouveau personnage pour avoir tout à disposition sous la forme
if (Wanda.blessure == true) …
C’est un peu impressionnant quand on débute, car il y a plein de nouveaux mot clés à apprendre mais cela devient rapidement indispensable pour simplifier son code et limiter les bugs.
Il y a beaucoup de documentations sur les forums et si tu en as besoin il y aura du monde pour t’aider.
Pour le moment tu peux t’en passer pour prototyper ce que tu veux faire, mais garde à l’esprit que cela existe et que cela peut te servir quand tu seras plus à l’aise.

Ah, je me connecte synchro avec ta réponse

D'accord, j'y vois plus clair !

C'est juste que du coup, la structure dont tu parles, ça correspond à quoi concrètement ? Une fonction personnalisée du même type que ce que j'ai pu faire pour tirer aléatoirement les cartes ? En fait, c'est une fonction qui va programmer les sprite dynamique des personnages avec des noms génériques ?

Je suis bosseur, donc c'est vrai que si ça peut simplifier le code, je veux bien prendre le temps d'aborder cette option

EDIT : est-ce que c'est ce genre de choses ?

https://www.adventuregamestudio.co.uk/wiki/Referencing_custom_struct_types