Différences

Cette page vous donne les différences entre la révision choisie et la version actuelle de la page.

@@ Ligne 1: / Ligne 1: @@
+[[ags|{{:contents.gif}}]] [[scripting|{{:up.gif}}]] [[tutoriel_de_scripting_partie_2|{{:back.gif}}]] [[migrer_vers_ags_2.71|{{:forward.gif}}]]
+----
+====Migrer vers AGS 2.7====
+Le langage de script d'AGS 2.7 a drastiquement changé par rapport à celui des versions précédentes.
+Beaucoup de commandes sont devenues // orientées objet // , ce qui présente plusieurs avantages par rapport
+à l'approche précédente. Cette page tentera de vous présenter les nouvelles méthodes et d'en expliquer
+les avantages.\\ \\
+Tout d'abord, pour que vous vous fassiez une idée des changements, voici un exemple de certaines
+commandes dans l'ancien style, et leurs équivalents :
+  AnimateObjectEx(0,2,0,0,0,1);
+  ListBoxAdd(3, 5, "Nouvel objet");
+devient :
+  oCascade.Animate(2, 0, eOnce, eForwards, eBlock);
+  lstTest.AddItem("Nouvel objet");
+Rien qu'en regardant cet exemple les avantages devraient être évidents ; l'apprentissage du script est plus
+intuitif, il est plus facile à lire (il n'y a plus à trouver ce que signifient les chiffres dans la fonction
+AnimateObjectEx), et ainsi vous êtes moins à même de faire des erreurs en l'utilisant.
+Les contrôles de GUI ont désormais des noms ce qui s'approche du style de GUI dans Visual Basic,
+et vous n'avez plus à vous rappeler les numéros de chacun de vos contrôles.\\ \\
+La fonction de l'éditeur d'auto-complétion du script a été significativement améliorée
+pour vous aider. Vous verrez en commencer à tester que l'auto-complétion s'affiche plus souvent
+et ne liste que les commandes pertinentes grâce au scripting orienté objet.\\ \\
+ ** Cela signifie-t-il alors que je dois jeter tous mes anciens scripts ? ** \\ \\
+Non, ben sûr que non ! Cette nouvelle version est totalement rétro-compatible, ainsi tous vos
+anciens scripts continueront de fonctionner normalement. Toutefois, lorsque vous écrivez de nouveaux
+scripts, il est fortement recommander d'utiliser les nouvelles commandes orientées objet.\\ \\
+ ** D'accord, alors euh... qu'est-ce qui a changé exactement ? ** \\ \\
+La syntaxe du langage de script n'a pas changé du tout (la façon dont vous utilisez les point-virgules,
+les accolades, etc.). Ceci est comme avant, mais avec quelques ajouts. Le plus significatif concerne
+les commandes qui sont désormais appelées ** sur quelque chose **. Par exemple, l'ancienne commande :
+  StopMoving(EGO);
+Au premier regard, il n'est pas facile de dire ce que fait StopMoving. Cela stoppe-t-il le déplacement
+d'un personnage, d'un objet, ou le mouvement de l'écran ? Ce n'est pas intuitif.
+Désormais, plutôt que passer le personnage comme un paramètre de cette fonction, vous appelez véritablement
+la fonction ** sur ** le personnage. De cette façon :
+  character[EGO].StopMoving();
+Désormais, il est parfaitement clair que c'est le personnage EGO que nous voulons stopper.\\ \\
+Imaginez que vous vous demandiez quelle commande appeler sur un personnage. Avant, c'était difficile
+à dire, mais maintenant si vous tapez  character[EGO].  dans l'éditeur de script, l'auto-complétion
+affichera une liste de toutes les fonctions et propriétés disponibles pour les personnages.\\ \\
+ ** Je dois donc taper character[EGO] à chaque fois ? Quelle plaie ! ** \\ \\
+Pas si vite ! La plupart des nouvelles commandes orientées objet peuvent être appelées de deux
+façons -- soit depuis un tableau comme nous venons de voir, mais aussi depuis ce qui s'appelle le
+ ** Script O-Name ** du personnage. C'est un raccourci qui vous permet d'accéder directement aux éléments,
+et pour les personnages cela correspond au nom de script précédé de "c".
+Ainsi, pour cet exemples nous aurions :
+  cEgo.StopMoving();
+Cette ligne a le même effet que celle avec character[EGO] que nous avons utilisée plus haut.\\ \\
+De plus, la variable // player // correspond désormais touours au personnage joueur en cours,
+c'est donc très pratique. Dans un jeu à plusieurs personnages, ce que vous écriviez ressemblait
+à ça :
+  StopMoving(GetPlayerCharacter());
+Cela peut désormais se faire ainsi :
+  player.StopMoving();
+ ** Hmm, je vois... donc qu'est-ce qui a été objectivé exactement ? ** \\ \\
+Acutellement, les éléments orientés objet suivant sont utilisables : \\ \\
+^ Tableau global      ^ Exemple de O-Name       ^
+| character[]    | cEgo             |
+| object[]       | oPorte           |
+| hotspot[]      | hArbre           |
+| gui[]          | gInventaire      |
+| inventory[]    | iAfficheRose     |
+| region[]       | (aucun)          |
+\\
+Les contrôles GUI sont géré assez différemment. Ils ont tous un nom de script, et on y
+accède directement grâce à eux. Par exemple, si vous donnez à une list box le nom de script
+"lstSaves", alors vous utiliserez "lstSaves." pour y accéder. Il n'y a pas de tableau global
+pour les contrôles de GUI.\\ \\
+ ** Comment je trouve les nouveaux équivalents des anciennes fonctions ? ** \\ \\
+L'index du fichier d'aide a été mis à jour pour vous rediriger automatiquement vers les nouvelles commandes.
+Ouvrez juste le fichier d'aide, allez à l'index et tapez le nom de l'ancienne commande, et cela affichera
+le nouvel équivalent orienté objet (s'il existe).\\ \\
+ ** Quelles commandes n'ont pas été changées ? ** \\ \\
+Les commandes qui n'agissent pas sur quelque chose en particulier (et qui n'auraient donc pas vraiment
+profité de l'orientation objet) ont été épargnées. Par exemple, SaveGameSlot, QuitGame et autres
+n'ont pas changé par rapport aux anciennes versions.\\ \\
+ ** C'est quoi ces trucs "eBlock" ? ** \\ \\
+AGS supporte désormais les ** types énumérés **. Basiquement, dans les situations où vous devez
+choisir dans une liste d'options possibles, un type énuméré (ou // enum //) est désormais introduit.
+Précédemment, vous aviez des commandes avec des descriptions comme :\\ \\
+"Passez 1 si vous voulez que la fonction bloque, 0 si vous ne le voulez pas.".\\ \\
+Cela faisait beaucoup de 1 et de 0 dans les appels de fonctions, ce qui rendait la lecture difficile.
+Maintenant, chaque numéro est plutôt représenté par un mot facile à se souvenir (comme //eBlock// et
+//eNoBlock//). Encore mieux, lorsque vous appelez une fonction qui utiliser un paramètre enum,
+l'auto-complétion affiche automatiquement une liste d'options parmi lesquels choisir.\\ \\
+Voyez la description du [[Mots-Clés#enum|mot-clé enum]] pour des informations sur la façon d'en créer.\\ \\
+ ** Alors je dois passer toutes ces choses comme eBlock chaque fois que j'appelle la fonction ? ** \\ \\
+Non ! Beaucoup de fonctions supportent désormais les ** paramètres optionnels **, où les options les plus
+courantes sont sélectionnées automatiquement. Si vous consulter l'aide pour une fonction comme
+[[Character#Character.Animate|la commande de personnage Animate]], vous verrez que certains paramètres sont définis
+comme "optionnels". Cela signifie que vous n'avez pas à les spécifier ; si vous ne le faites pas,
+l'option qui sera choisie par défaut est décrite dans l'aide pour cette commande.\\ \\
+ ** Quoi d'autre est nouveau ? ** \\ \\
+Eh bien, la version 2.7 introduit le type de données // float //, AGS supporte donc finalement
+les calculs décimaux dans vos scripts. De plus, pour les codeurs plus avancés, vous pouvez
+créer vos propres fonctions membres (incluant les protégées -- //protected// -- et les statiques)
+afin d'écrire des scripts plus propres que si vous aviez un tas de fonctions globales.\\ \\
+Aussi, l'éditeur de script détecte maintenant plus efficacement vos erreurs. Il se peut que
+des scripts qui se compilaient sans soucis avant ne fonctionnent plus sur la 2.7.
+Normalement, le message d'erreur devrait vous signaler directement le problème.\\ \\
+ ** Y a-t-il autre chose à quoi je dois me préparer ? ** \\ \\
+A cause des nouveaux ajouts, le langage de script a davantage de mots réservés qu'avant.
+Par exemple, des mots comme "gui", "object" et "hotspot" sont désormais réservés (puisqu'ils
+sont utiliser pour accéder aux tableaux globaux). Si votre script utilise des variables qui
+portent ces noms, il y aura désormais conflit. Vous devrez changer les noms de ces variables
+pour pouvoir compiler.\\ \\
+Aussi, le langage de script supporte désormais les // pointeurs //. Vu que c'est un sujet
+assez complexe, il y a une [[Pointeurs#Pointers|page séparée]] qui leur est consacrée.\\ \\
+ ** Eh bien, ça fait beaucoup. Par où je commence ? ** \\ \\
+Je vous recommanderais d'essayer d'écrire votre prochain script de la nouvelle façon.
+Chaque fois que vous êtes sur le point d'utiliser une commande de l'ancien style, regarder
+simplement dans le manuel pour trouver son nouvel équivalent.\\ \\
+Une fois que vous serez habitué au nouveau système, je suis sûr que vous concéderez que
+c'est une amélioration significative par rapport à l'ancien système de script et vous commencerez
+à profiter des avantages d'un codage plus rapide et plus intuitif.\\ \\
+Comme toujours, s'il y a quelque chose qui vous tracasse véritablement, postez sur
+les Forums AGS et nous essayer de vous aider au  mieux !\\ \\
+Amusez-vous bien,
+CJ\\ \\
+ ** Suite : **  [[Pointeurs#Pointers|Les pointeurs dans AGS]]
+{{tag>français}}