Bienvenue sur le manuel de GBA Graphics!

Ce programme vous permet de convertir vos graphismes pour les utiliser sur votre Game Boy Advance.
Vous pouvez trouver la dernière version sur mon site ou dans le topic où je l'ai lancé sur le forum de playeradvance

Ce manuel aurait besoin d'être traduit en anglais. Malheureusement, je n'ai pas les connaissances nécessaires pour cela. Si vous voulez vous proposer pour le faire, n'hésitez pas! Vous pouvez m'envoyer un e-mail. Merci d'avance ;-)

Et maintenant?

Vous a-t-on déjà dit que vous devriez vraiment lire tout le manuel avant de commencer? Bon ok, là il est un peu long, je vous l'accorde. Pour débuter, évitez donc ce qui vous semble compliqué (en gros tout ce qui parle de script) mais faites tout de même un tour d'horizon, vous y apprendrez pas mal de choses qui vous faciliteront énormément la vie.

L'interface

Ce n'est pas très compliqué à comprendre. Mais voici une petite description; A gauche se trouve votre projet, incluant les jeux de mosaïques, cartes et autres éléments.
Pour ouvrir un menu, cliquez sur le plus situé à sa gauche. Si vous sélectionnez un élément à la racine de votre projet (par exemple Cartes), un formulaire apparaîtra à droite, et vous permettra de paramétrer le nouvel élément à ajouter. Cliquez sur Ok ou appuyez sur Entrée pour valider.

Menu contextuel du projet

Cliquez avec le bouton droit de la souris sur un élément de votre projet. Un menu s'ouvrira, il vous permettra de renommer ou de supprimer l'élément, de voir le fichier .c correspondant ou encore, s'il s'agit d'une carte, de l'éditer.

Création d'un nouveau projet

Note: Cette section explique la méthode qui me semble la plus simple, mais vous n'êtes pas obligé de la suivre. Imaginons donc que vous allez démarrer un grand projet.
Dans le dossier du projet C, je crée toujours un dossier de resources, que je nomme "Res". Voilà l'arborescence du répertoire d'exemple:

Projets GBA\
    Mario\
        Res\
            aide.htm
            GBA Graphics.exe
            Niveau1_graphismes.bmp
            Sprites.bmp
        Mario.vhw
        Mario.c
        Makefile
        ...

Note: Si vous utilisez ce schéma, vous pouvez laisser GBA Graphics dans ce répertoire et distribuer votre source ainsi.

Comme vous le voyez, j'ai copié GBA Graphics dans le dossier Res, qui contient toutes les images, et les documents qui seront créés par ce programme. Pour les inclure à mon projet, j'utilise donc toujours des inclusion du type:

#include "Res/Niveau1.map.c"

Une fois que vous l'avez donc mis dans votre répertoire de travail, lancez GBA Graphics. La première fois, il créera automatiquement un nouveau fichier projet (quand vous quittez). A présent, tout ce que vous ferez depuis ce répertoire sera sauvé dans le fichier projet "Projet.pgg". Rien ne vous empêche de le sauver à un autre endroit mais cela n'en fera qu'une copie (le projet par défaut chargé par GBA Graphics restera toujours Projet.pgg, à moins que vous en spécifiiez un autre en argument).
Si vous distribuez la source, incluez le fichier aide.txt pour que celui qui voudra lire vos graphismes ne soit pas perdu... :)
C'est flou, mais l'avantage de cette méthode est qu'il n'y a pas besoin d' enregistrer à chaque fois votre projet, et que si vous distribuez votre source, et qu'il suffira à celui qui voudra la relire de lancer GBA Graphics pour avoir accès au ressources puisqu'elles se trouvent enregistrées dans le répertoire.
Note: Ces étapes ne sont pas obligatoires (vous pourriez laisser GBA Graphics à un endroit particulier et enregistrer le projet sous un autre nom lorsque vous voulez en commencer un nouveau). C'est vous qui voyez :)

Conversion de mosaïques

Faites un petit tour des différents types d'élément que vous pouvez créer et utiliser avec ce programme. Après cela, nous allons effectuer notre première conversion: celle d'une image en mosaïques, dûment accompagnées d'une palette et d'une map.
Pour cela, munissez-vous d'une bitmap 24 bits (d'une petite taille, genre 256x256). Ensuite, ouvrez GBA Graphics et sélectionnez dans l'arbre l'objet Mosaïques à la racine. Sur le côté droit de la fenêtre, vous verrez un formulaire demandant les noms de fichiers et options. Pour commencer, cliquez sur le premier bouton parcourir depuis le haut, et sélectionnez le fichier bitmap à convertir (qui devrait logiquement être le seul à être immédiatement proposé si vous avez suivi la procédure ci-dessus). Les trois autres champs en dessous sont automatiquement remplis. Normalement, vous ne devriez pas avoir besoin de les modifier. Faisons maintenant un petit tour des options disponibles:

-Choisissez le type de map (texte ou rotation). Le plus souvent, vous utiliserez le type texte (16 bits) et le type rotation code chacun des blocs de la map sur 8 bits.
-Vous pouvez choisir d'ajouter le résultat à une palette et un tileset existant, ou d'en créer de nouveaux.
-Vous pouvez choisir si vous voulez générer un map ou non (pour l'exemple, choisissez oui)
-Activer le mode 16 couleurs (4 bits par pixel), sinon c'est le mode 256 couleurs (8 bits) qui sera utilisé
-Choisir le nombre de couleurs maximal à utiliser pour la conversion (surtout utile si vous fusionnez plusieurs palette à l'aide de l'option Palette existante ci-dessus)
-Choisir si vous voulez optimiser le tileset en groupant les mosaïques identiques. Le groupage sera effectué en fonction du format de mosaïques défini à droite (8x8, 16x16, 32x32, personnalisé).

Une fois vos choix effectués, cliquez sur Ok ou appuyez sur la touche Enter. Des éventuels avertissements quant à la conversion des couleurs ou la taille pourront apparaître. Vous pouvez à ce moment annuler la conversion en cliquant sur Annuler ou continuer en cliquant sur Ok (ici, n'annulez pas).
Lorsque la conversion sera terminée, trois éléments se seront ajoutés à votre projet: un jeu de mosaïques, une palette et une map.

Editeur de maps

GBA Graphics inclut un petit éditeur de cartes, à utiliser comme éditeur de niveaux universel à défaut de pouvoir en faire un vous-même pour votre jeu.
Note: Cet éditeur devrait en fait suffir pour une bonne partie de vos projets.

Tout d'abord, créez une image dont les mosaïques de la taille voulue seront placées à la verticale. Par exemple une image qui contient 5 mosaïques de 16x16 fera 16 pixels de largeur et 80 pixels de hauteur. Mais vous pouvez également les placer à l'horizontale et faire plusieurs lignes (par exemple 8 mosaïques par ligne et 4 lignes -> 32 mosaïques).
Convertissez-la ensuite en utilisant la procédure de conversion de mosaïques décrite ci-dessus.
Juste à côté de la case "Optimiser le tileset", choisissez la taille de chacune de vos mosaïques dans l'image (par exemple 16x16), ou 8x8 pour un plan standard, etc.
Si vous utilisez des mosaïques plus grandes, il vous faudra les assembler avant de pouvoir les afficher sur GBA. Une mosaïque de 16x16 est composée de 4 mosaïques de 8x8, placées comme suit:

0 1
2 3

Réglez également si vous voulez générer votre tileset en 16 couleurs et le nombre de couleurs maximal disponibles.
Finalement, cliquez sur Ok. Les éléments seront ajoutés au projet. Maintenant sélectionnez Cartes dans votre projet. Entrez le nom du fichier map que vous allez utiliser, par exemple Niveau01.map.c.

Sélectionnez le tileset, la palette et la taille des blocs à utiliser. Vous pouvez déjà spécifier une taille à votre tableau (elle sera modifiable par après). Cliquez sur Ok, la nouvelle map sera ajoutée au projet.
Ouvrez le menu Cartes et choisissez-la (ici elle s'appellerait niveau01).
Pour ouvrir la carte une fois celle-ci sélectionnée:
-Cliquez sur Éditer dans la zone de droite
-Appuyez sur Entrée
Et si elle n'est pas encore sélectionnée:
-Cliquez dessus le nom de la carte avec le bouton droit et choisissez Editer. Cette méthode ouvrira la map plus rapidement si votre ordi n'est pas très puissant.
-Double-cliquez tout simplement sur le nom de la carte.
L'éditeur s'ouvrira ensuite.

Ici, cliquez avec la souris sur l'une des mosaïques à votre droite pour l' utiliser. Elle se mettra à clignoter lorsque vous passerez la souris au-dessus de la map. Là, cliquez avec le bouton gauche pour la placer. Vous pouvez déplacer la souris en maintenant le bouton appuyé pour remplir toute une zone de cette mosaïque.
Vous pouvez également sélectionner des blocs dans une zone quelconque en cliquant sur votre map avec le bouton droit. Un rectangle bleu clignotant apparaîtra au-dessus de la zone sélectionnée. Une fois que vous relâcherez le bouton droit, la zone sera copiée. Ensuite, le curseur clignotant prendra la forme de la première mosaïque (coin haut-gauche) copiée. Vous pouvez cliquer avec le bouton gauche et glisser la souris sur une zone importante pour placer la zone copiée, qui sera éventuellement répétée dans le rectangle. Si tout fonctionne bien, vous verrez votre zone qui clignotera tant que le bouton gauche de la souris sera enfoncé. Pour placer la zone, relâchez-le.
Note: Appuyez sur les deux boutons de la souris en même temps pour annuler toute sélection active.

Vous pouvez également utiliser la roulette de la souris pour sélectionner les motifs les uns après les autres. Si un bloc est copié, alors celui-ci sera remplacé par le motif qui était sélectionné avant la copie.

Les touches

Il y a peu de raccourcis. Ce sont les suivants:

-Ctrl+Z: Annuler la dernière opération
-Ctrl+Y: Annuler l'annulation (refaire)
-Ctrl+S: Sauvegarder la map active. Un message OnSave accompagné du nom de la map est alors envoyé au script.
-Ctrl+H: Passer/Sortir du mode hexa.
-Ctrl+1-5: Passer rapidement entre les maps ouvertes.
-Touches directionnelles: Faire défiler la map
-Ctrl+V: Si vous avez copié une zone d'écran, permet de la coller au même endroit que celui où vous l'avez copiée.

Menu de la fenêtre principale

Les menus ne sont pas trop compliqués à comprendre. Passons-les en revue rapidement;

Menu Fichier

Ce menu vous propose de créer un nouveau projet, de l'enregistrer ou d'en ouvrir un autre.
Personnellement, je vous déconseille d'utiliser ces fonctionnalités, car le projet par défaut est et reste "Projet.pgg" dans le répertoire courant, c'est plus simple.
Vous pouvez également quitter le programme sans sauver les modifications apportées au projet courant.

Menu Affichage

C'est un menu "à tout faire", que je ne savais pas trop comment nommer. Les options sont déjà un peu plus intéressantes:

-Actualiser: Met à jour l'arbre du projet courant. Inutile à moins d'avoir un bogue (mais ça n'est pas arrivé encore).
-Invite de script: Vous pouvez appuyer sur Ctrl+I à tout moment (éditeur compris) pour faire apparaître l'invite de script et exécuter une commande. Toutefois, ne faites pas n'importe quoi (comme supprimer des maps alors que l'éditeur est ouvert).
-Couleurs...: Fait apparaître la boîte de dialogue de correction de couleurs et de luminosité, décrite ci-dessous.
-Ajouter dossier: Permet d'ajouter un dossier. Choisissez dans quel dossier vous voulez le placer. Voyez la section Dossiers personnels plus bas dans ce document.

Effets de couleurs et luminosité

Cette boîte de dialogue permet de configurer toutes sortes d'options qui seront utiles à la conversion des images. Vous pouvez notemment choisir la couleur transparente et modifier la luminosité, ce qui est un point non négligeable, surtout sur GBA! ;-)

A la base, cette fonction était prévue pour être utilisée à partir du script, et si vous vous y mettez, vous verrez qu'il y a encore plus de possibilités! Toutes ces options ont donc leur équivalent en script comme sera décrit plus bas.

-Couleur transparente: Vous permet de choisir la couleur qui sera traitée comme transparente dans l'image que vous convertissez. Par défaut, il s'agit d'un rose violacé qui n'est pour ainsi dire jamais utilisé dans les images: RGB(255,0,254). Il suffit de cliquer sur le carré coloré et choisir ensuite une couleur dans la liste (vous pouvez également y entrer les composantes de rouge/vert/bleu vous-même).
-Correction gamma: Permet de corriger la courbe de luminosité (qui n'est pas linéaire à la base, ce qui explique pourquoi il est si dur d'avoir un écran dont la luminosité est sans défaut). C'est une méthode très efficace pour augmenter la luminosité.
-Addition (de blanc): Ajoute la valeur suivante à chaque couleur. Le résultat est généralement inférieur à celui donné par la correction gamma, en revanche il donne un bel effet sur GBA SP.
Note: N'oubliez pas qu'additionner une couleur négative revient à la soustraire, et donc à la rendre plus foncée. Les couleurs sont plafonnées en haut et en bas lors de ces opérations.
-Vers le blanc: Effectue une moyenne entre la couleur en question et le blanc (avec un coefficient différent pour les deux couleurs: x et 255-x). Les couleurs sont donc ramenées linéairement vers le blanc. Contrairement à ce que l'on pourrait penser, cet effet n'est pas très efficace lorsqu'il s'agit d'augmenter la luminosité, en revanche, il est très bon pour la diminuer, et en choisissant des coefficients différents pour les canaux de rouge/vert/bleu, vous pouvez créer d'excellents effets de couleurs. Mais pour cela, il faut utiliser le script.
Note: Si vous mettez des valeurs négatives, GBA Graphics effectuera une moyenne avec le noir et non le blanc.
-Nuances de couleurs: Permet de choisir le nombre de nuances qui seront utilisées pour chacun des canaux de rouge/vert/bleu. Sur GBA, on a 32 nuances pour chaque canal, soit 32^3 = 32768 couleurs. Vous pouvez diminuer cette valeur pour arrondir les couleurs ou pour en économiser. C'est utile si vous utilisez par exemple des graphismes de NES (4 tons), de Mega Drive (8 tons) mais ça n'a clairement aucun sens si vous créez vos propres graphismes.
-Appliquer l'effet nuances avant les autres: Contrôle si les effets de nuances sont appliqués avant ou après les autres (gamma et cie). Cela définit donc si les couleurs seront arrondies avant ou après être traitées. Sur PC, la valeur max est 255, sur GBA 31. En divisant par huit (si 32 nuances sélectionnées), on trouve 31 mais on perd de la précision puisque 31*8=248 et non 255 (c'est le cas extrême). Mais c'est utile si vous avez par exemple des graphismes de Mega drive provenant de plusieurs sources; si les couleurs ne sont pas exactement les mêmes, le résultat risque d'être erroné si vous modifiez le gamma (qui rapproche ou éloigne les couleurs).
Exemple: 2 teintes, 128 (venant d'un prog) et 132 (venant de l'ému) sont supposées identiques car 128/8 = 132/8 = 16. Mais en augmentant le gamma (1.6), cela donne 165 et 168. 165/8 = 20 et 168/8 = 21. Deux couleurs seront créées au lieu d'une, des optimisations de tileset disparaitront, ainsi tous les blocs de maps seront décalés -> problème. En appliquant d'abord l'effet nuances, 128 et 132 sont vraiment identiques, quel que soit le gamma. Mais décochez cette case si vous n'utilisez que vos propres graphismes.
-Méthode de conversion: Vu la médiocrité de mon algorithme de réduction de couleurs, j'ai tenté d'en implémenter un autre en suivant des docs cette fois :-) Et j'ai également fourni un dithering fait automatiquement par Windows en mode "halftone". Voyons les caractéristiques des différentes méthodes:
--Standard: C'est ma méthode, elle permet en plus des autres d'ajouter les couleurs à une palette tout en conservant les couleurs déjà existantes et en les utilisant si besoin est.
--Tramé: Méthode rendue par Windows (= peut ne pas marcher si votre version de Windows n'est pas suffisemment récente). La palette utilisée est standard à Windows, et vous ne pouvez pas ajouter à une palette déjà existante. La taille de la palette créée est toujours 256 couleurs.
--Optimal: Deuxième implémentation de ma réduction de couleurs, beaucoup plus efficace et rapide, mais qui dispose d'une fonctionnalité en moins; si vous mettez "palette existante", il ajoutera bien à la palette, mais ne pourra pas se servir des couleurs déjà existantes (car il serait censé pouvoir les modifier mais en fait là ce n'est pas possible). C'est pourquoi cette méthode n'est pas proposée par défaut.

Je ne sais pas si cela vous sera utile, mais la formule utilisée pour calculer la valeur de chacune des composantes de chaque pixel est la suivante (chacun des facteurs alpha/gamma/addition ont trois canaux: rouge/vert/bleu):

couleur= (int)max(min(((int)(((min(Alpha,0))+(255-ABS(Alpha))*((255.0*pow((valeur/255.0),Gamma))+Addition)/255+0.5)/(256.0/(nuances+1))))*(31.0/nuances),31),0)

Comme je l'ai précisé plus haut, vous pouvez effectuer la même chose (et même mieux) avec le script. Mais comme on n'est encore qu'au début du manuel, je ne vais pas vous surcharger avec ça. Si cela vous intéresse, rendez-vous plus bas dans la section Options de conversion (scripté).

Menu procédures

Ce menu affiche les procédures exportées du script chargé. Voir la section Script pour plus d'informations. Notez tout de même que pour définir une procédure exportée, il suffit de rajouter un trait de soulignement avant son nom. Exemple:

_Ma Procédure:
    [mon code]
    Fin

Vous pourrez alors choisir "Ma Procédure" dans le menu Procédures et le code sera exécuté dans ce cas.

Menu Aide

Je pense qu'il est clair non? :)

Menu de l'éditeur

Ce menu vous permet de faire pas mal de choses. De nouvelles options apparaîtront dans certaines circonstances. Pour l'ouvrir, cliquez sur le bouton Menu dans l'éditeur.

Mode hexa

Cette option vous permet d'éditer votre map non pas graphiquement, mais à l'aide des nombres en hexadécimal. Une fois cette option sélectionnée, elle sera remplacée par un sous-menu vous permettant de régler trois options:

-Annuler: Vous permet de retourner au mode graphique.
-Combler avec des 0: Comble les blocs de zéros (essayez pour vous en rendre compte).
-Map graphique en fond: Affiche la map graphique en transparence en-dessous de la map texte.
Attention: Cela ne fonctionne qu'avec les maps de 16x16.

Le mode hexa était surtout utile au début, mais maintenant le mode graphique a bien assez de fonctionnalités pour pouvoir s'en passer quasiment complètement.

Niveaux multi-couches

Avec cette nouvelle version, vous pouvez éditer plusieurs maps en même temps. Pour cela, choisissez dans le menu l'option Ajouter un fond... puis le fond que vous voulez voir ou éditer. Avec les anciennes versions, vous pouviez déjà ajouter des fonds histoire de voir plusieurs maps en même temps (utile pour éditer la map de collision par-dessus la map graphique), mais vous ne pouviez pas l'éditer simultanément. A présent, c'est possible. Et si vous étiez déjà familiarisé avec l'éditeur, vous verrez que rien n'a changé: seul un menu supplémentaire vous permettra de choisir quel est le fond actif (celui que vous éditez) et vous pourrez ensuite les enregistrer tous en même temps à la fermeture du programme ou individuellement en appuyant sur Ctrl+S lorsque la map que vous voulez sauver est active.
Il y a également une meilleure gestion des Annuler/Refaire et de la sauvegarde, et quelques fonctions en plus.

Une fois le fond ajouté comme dit plus haut, vous avez accès à un menu supplémentaire, Fonds..., qui vous propose les options suivantes:

-Actif...: Vous permet de choisir lequel des fonds vous éditez parmi la liste des maps ouvertes. Vous pouvez utiliser les touches Ctrl+1-5 pour en choisir une directement.
-Affichés...: Vous pouvez choisir d'afficher ou non l'un des fonds.
Note: Le fond actif est de toute façon affiché et passe toujours au premier plan, car ça n'a aucun sens d'éditer une map que l'on ne voit pas!
-Lier...: Fait apparaître un assistant pour la liaison de vos maps. Lors de la liaison, les opérations annuler/refaire sont perdues sur les plans en question. Voir Liaison de maps plus bas dans ce document.
-Une palette par fond: Permet à chacun des fonds d'utiliser sa propre palette. Si vous désactivez cette option, vous aurez le rendu tel qu'il apparaît sur une vraie GBA, puisque tous les plans partagent la même palette. C'est pratique pour tester.
-Fonds transparents: Affiche le premier plan et les fonds en transparence. N'oubliez pas que tous ces paramètres sont modifiables automatiquement à l'aide du script, plus d'autres choses comme les niveaux de transparence respectifs des fonds et du premier plan.
-Map spécimen: Active ou désactive la fenêtre de la map spécimen (n'est disponible que si des fonds ont été associés par l'intermédiaire de l'objet specimen). Voir Map spécimen plus bas.

Grille des bits

La grille des bits est un outil qui vous permet d'éditer visuellement et simplement la sélection courante de manière binaire. Il s'agit d'une nouvelle fonctionnalité, introduite dans la version 0.95. Vous pouvez y accéder par le biais du sous-menu "Outils..." du menu principal de l'éditeur.

Il y a huit cases à cocher, représentant les bits de 8 à 15. Lorsque vous sélectionnez une zone dans la map, l'état du bloc se trouvant le coin gauche de la sélection est inscrit sur la grille des bits. Il suffit alors de cliquer sur la case à cocher représentant le bit à changer, sans oublier de coller la sélection pour valider le changement.

Bien entendu, cela ne s'arrête pas là. Vous pouvez également renommer chacune des étiquettes associées aux différentes cases à cocher, et choisir si vous voulez activer la case ou non (lequel cas elle sera grisée). Cependant, comme ces fonctions requièrent l'utilisation du script, et sont donc décrites plus bas dans ce document, à la section Grille des bits (scripté).

Options de l'éditeur

Pour cela, choisissez Options... dans le menu principal de l'éditeur. Vous pouvez paramétrer les choses suivantes:

-Dimensions de la map: Réglez, en nombre de blocs, la largeur et la hauteur de la map. Aucune information n'est perdue durant ce procédé, sauf si vous diminuez la taille finale de la map et que la partie supprimée contenait des blocs importants.
Attention: Après redimensionnement d'une map, vous ne pourrez plus annuler les opérations antérieures. Cependant, il reste toujours la possibilité de ne pas enregistrer la map si le résultat est erroné.
-Mosaïque de référence: Il s'agit du numéro de la première mosaïque qui sera utilisée. Généralement cette valeur est zéro, car on commence avec la première mosaïque du tileset, mais rien ne vous empêche d'en décider autrement.
-Masque d'affichage: Le masque d'affichage est un ET logique appliqué à chaque bloc de map avant d'être affiché. Si vous appliquez un masque de 15, seuls les 4 premiers bits pourront être utilisés pour le numéro de mosaïque. Si vous mettez une valeur de 17 ensuite, celle-ci passera à 1, cependant rien ne sera changé dans la map, ni en mode hexa. Cela n'affecte que l'affichage.
Note: Comme vous n'utiliserez généralement que 10 bits pour le numéro de mosaïque, vous devriez utiliser un masque de 1023. Les valeurs binaires (0b1111111111) et hexadécimales (0x3ff) sont également acceptées. Cela vous permet alors d'utiliser les autres bits (10 à 15) pour des flags personnels, comme la profondeur, le miroir, et autres... sans influer sur l'affichage.
-Format blocs: Fait apparaître une autre boîte de dialogue vous permettant de modifier la taille de vos blocs. Ce système est plutôt foireux, et ne fonctionne pas pour augmenter la taille de vos tiles à cause de l'optimisation éventuelle et du placement qui n'a pas été prévu pour.
-Zoom écran: Permet de paramétrer le zoom appliqué. 2 signifie qu'il sera deux fois plus grand. Le plus souvent, vous utiliserez des nombres à virgule, comme 1.5.
Note: des valeurs inférieures à 1 offrent un dézoomage. Cependant, la taille de l'écran étant limitée à 1024x1024, cela ne sera pas très utile si vous avez déjà une résolution très grande.
-Zoom bilinéaire: Permet d'appliquer un effet de lissage au zoom, pour le rendre plus précis. Cela utilise SetStretchBltMode(hdcEcran,HALFTONE), donc peut être très lent chez vous. Ne l'activez pas si vous utilisez un zoom de 1, à moins que vous soyez en 256 couleurs ou moins.
-Afficher la grille: Permet d'afficher une grille délimitant chaque bloc de la map. Vous pouvez paramétrer cette grille en utilisant le script (n'oubliez pas, Ctrl+I pour appeler l'invite de script) grâce aux variables suivantes:
Editeur.alphaGrille=(entier) définissant le niveau de transparence de la grille entre 1 et 255.
Editeur.couleurGrille=(couleur rgb) définissant la couleur de la grille.

Opérations sur la sélection

C'est une fonctionnalité bien sympathique (et toute nouvelle) qui permet d'appliquer des opérations arithmétiques en fonction de conditions définies sur la sélection active.
Vous devez d'abord sélectionner quelques blocs. Pour cela, cliquez avec le bouton droit de la souris et glissez le rectangle bleu jusqu'où vous désirez inclure la sélection. Relâchez le bouton gauche pour copier les blocs. Vous pouvez ensuite les coller sur une zone donnée en cliquant avec le bouton gauche et en glissant pour étendre la sélection.
Note 1: Appuyez sur les deux boutons de la souris en même temps pour annuler toute sélection active.
Note 2: Si la sélection avec le bouton gauche est plus grande que le motif copié, il sera répété dans sa largeur ou sa hauteur.

Ensuite, choisissez Opération sur sélection dans le menu (l'élément ne sera plus grisé si vous avez bien copié un bloc). Vous verrez alors deux champs: un champ opération et un champ condition.
Dans cet exemple, je veux appliquer le bit de profondeur sur un arbre (le 11ème, soit faire un OR 1024 sur mes blocs). Seulement, comme ma sélection est "carrée", elle contient aussi du vide (0), et de l'herbe (2) en-dessous. Je ne veux pas appliquer de bit sur ces blocs-là.
Je remplis donc le champ opération avec |0x400, | étant l'opérateur OU (voir ci-dessous) et 0x400 étant le bit 11 seul (j'aurais pu le mettre en binaire 0b10000000000 ou en décimal 1024).
Ensuite, je remplis le champ condition comme suit: !=0 et !=2, ce qui n'appliquera donc l'opération qu'aux blocs qui ne valent pas 0 et ne valent pas 2 (le != étant l'opérateur d'inégalité, voir ci-dessous).

Voici une table des opérateurs arithmétiques et logiques disponibles, ainsi que les opérateurs de condition:

Si vous utilisez le & dans le cadre d'une condition, celle-ci sera considérée comme vraie si le résultat d'un ET bit à bit entre la valeur présente et celle spécifiée est non nul. Par exemple &0b10 n'effectuera l'opération que si le deuxième bit vaut 1. Pour tester si le bit est zéro, utilisez ~0b10.
Vous pouvez également spécifier plusieurs conditions en les séparant d'un et ou d'un ou. Exemple:

>=2 et <7 ou >10 et !=16

Les opérations sont toujours effectuées de gauche à droite. Ainsi, ceci revient mathématiquement à faire:

((>=2 et <7) ou >10) et !=16

De la même manière, vous pouvez également entrer plusieurs opérateurs à la suite, par exemple:

+2*3 équivaut à (+2)*3

Une fois l'opération effectuée, vous pouvez coller les blocs quelque part, et pourquoi pas au même endroit?

Déplacements "DMA"

Cette fonctionnalité (nouvelle également) est accessible en choisissant Déplacer... dans le menu principal de l'éditeur. Cela sert à déplacer et copier rapidement et simplement des blocs de mémoire, car on était parfois bloqué puisqu'il était impossible de sélectionner des blocs plus grand que l'écran.
Je l'ai surnommé "DMA" car c'est une autre manière d'accéder à la mémoire, un peu plus bourrin mais toujours sécurisée et rapide.

Pour effectuer un déplacement de bloc, remplissez les trois champs, les positions de départ, la taille du bloc à copier (utilisez * pour copier toute la map si les positions de départ sont 0,0) et l'endroit où le déplacer. La zone déplacée sera remplie de zéros ensuite. Les déplacements sont annulables.

Mais vous n'êtes pas obligé de remplir tous les champs. Si vous ne remplissez que le champ Source et la taille, cela copiera le morceau de map choisi comme avec la souris (sauf que vous pouvez dépasser l'écran). Si vous voulez sélectionner toute la map, mettez 0 et 0 dans la source, et * et * dans la taille. Laissez les deux champs destination libres.

Vous pouvez ensuite coller ce morceau de map ailleurs. Si vous ne remplissez que les champs destination et éventuellement taille, la sélection sera collée à l'endroit défini par la destination.

L'effet du paramètre Seulement sur le plan actif permet, lorsque deux maps sont liés, de n'effectuer les déplacements (copier et coller compris) que sur le plan actif, sinon l'effet se verra sur tous les plans liés.

Liaison des maps

La liaison de maps est très utile lorsque vous travaillez sur plusieurs maps en même temps. Par exemple, si vous éditez simultanément votre map de collision et votre map graphique, si vous liez celles-ci, les opérations de sauvegarde, copier/coller, annuler/refaire, etc. seront communes aux deux maps.
Imaginez donc que vous voulez copier une partie de votre map et la coller ailleurs -> pas besoin de le faire une fois pour la map graphique et pour celle des collisions, tout est fait d'un coup.

Vous pouvez créer librement des groupes sur les maps ouvertes. Tout d'abord, allez sous "Ajouter un fond..." dans le menu principal. Ce fond apparaîtra au-dessous (éventuellement en transparence). Vous pouvez l'éditer individuellement en appuyant sur Ctrl+2. Revenez maintenant à la première avec Ctrl+1.
Maintenant, allez dans le menu "Fonds..." puis choisissez "Lier...". Une fenêtre apparaîtra, vous indiquant la liste des fonds liés. Par défaut, seule la map courante y sera (la 1 dans notre cas). Ouvrez la liste déroulante et choisissez la deuxième map ("2 = nom_de_la_map"). Elle sera ajoutée à la liste. Notez que les maps sont identifiées par leur numéro et séparées par des virgules.
Note: Les maps ne sont pas liées en cascade. Par exemple, si vous liez la map 1 avec la 2, et la 2 avec la 3, ne croyez pas que la 1 sera également liée à la 3 par l'intermédiaire de la 2. Si c'est ce que vous désirez, mettez 1,2,3 comme liens pour la première map.

Pour ne copier que les données du plan actif lorsque vous avez lié des maps, appuyez sur la touche Ctrl en même temps que vous relâchez le bouton de la souris. Lorsqu'une sélection (copie) n'a été effectuée que sur un seul plan, le collage le sera également (sans que vous ayiez besoin d'appuyer sur la touche Ctrl).

Maps spécimen

Cette commande requiert l'utilisation du script. Voyez plus bas pour apprendre à l'utiliser.

Vous pouvez créer des maps "spécimen" (maps modèles pouvant être sur plusieurs couches) auxquelles vous pourrez accéder simplement lors de l'édition de vos maps basées sur le même jeux de mosaïques que celui de la map spécimen. Cela se présente par une petite fenêtre dans laquelle vous irez sélectionner les blocs "tout faits" qui vous intéressent et que vous irez coller dans la map que vous éditer.
Les maps spécimen peuvent bien entendu se trouver sur plusieurs couches (graphiques + collisions par exemple). Pour les utiliser, c'est très simple; il vous suffit de les ajouter en utilisant la méthode AjouteMap de l'objet Specimen et de lui passer le numéro de la map (fond) à ajouter.
Lorsqu'un fond passe sur la fenêtre spécimen, il est automatiquement passé invisible sur l'éditeur de map standard. Pour le réactiver, utilisez le tableau visible de l'objet Fonds.
Bien entendu, vous devez faire cela directement à l'ouverture de l'éditeur sinon la fenêtre spécimen ne sera pas disponible. Voici un exemple concret de script:

#Qu'on ouvre la map graphique ou celle des collisions...
OnOpen map_graphique_niveau1:
OnOpen map_collision_niveau1:

    #Vide l'éditeur. Il faut s'assurer que l'ordre des maps soit correct.
    Fonds.Reinit
    
    Fonds.Ajoute "map_graphique_niveau1"       #Celle-ci en premier.
    Fonds.Ajoute "map_collision_niveau1"       #On va éditer les deux en même temps
    
    Fonds.LieMap 1,2                           #Donc il faut les lier
    
    Fonds.Ajoute "specimen_graphique"          #On ajoute les deux maps spécimen
    Fonds.Ajoute "specimen_collision"
    
    #Pourquoi l'ordre était-il si important? Car si on ajoute la map spécimen graphique
    #puis la map spécimen collisions, il faut également que les maps à éditer soient
    #dans cet ordre pour correspondre entre elles ;)
    Specimen.AjouteMap 3                       #Ajoute à la fenêtre spécimen la map n°3
    Specimen.AjouteMap 4                       #Et la 4 aussi...
    Fin

Vous ne comprendrez peut-être pas tout dans ce script, mais ça vous donne un exemple. Il est plus compliqué car il supporte l'éventualité que vous éditiez la map graphique OU la map de collision. Après, c'est à vous de faire un script qui corresponde à vos besoins.

Grille des bits (scripté)

Cette section est la suite de Grille des bits, se trouvant un peu plus haut. Ici, on abordera l'utilisation du script.
Pour chacune des cases à cocher, vous pouvez définir le texte affiché à côté et si vous voulez ou non activer la case (elle sera grisée sinon). Cela se fait à partir de l'objet Bits, dont la syntaxe est la suivante:
Bits[numéro_fond].Méthode numéro_bit, argument
Vous remarquerez que vous pouvez appliquer des définitions de bits individuelles pour chacun des fonds. Il faut également spécifier le numéro du bit que vous voulez modifier. Cette valeur va de 8 à 15, le bit 15 étant affiché au sommet de la fenêtre et le bit 8 au fond. Les bits 0 à 7 ne sont pas paramétrables et n'apparaissent pas dans cette fenêtre. Ils devraient de toutes façons être utilisés pour le numéro de motif.
Enfin, il faut entrer un argument qui représente la nouvelle valeur à placer comme décrit ci-dessous:

-texteBit: Permet de modifier le texte affiché à côté de la case à cocher. L'argument requis est une chaîne.
-bitActif: Permet de choisir si un bit est activé ou non. L'argument est un booléen (vrai ou faux).

Voici deux exemples:

Bits[1].texteBit 15,"Palette (8x)"
Bits[1].bitActif 14,faux

Note: Le fait de désactiver une case bit met également son texte à "(inutile)". Si vous voulez vraiment en changer le texte, faites appel à texteBit après bitActif.

Conditions sur les tiles (scripté)

Le nom de ce chapitre n'est pas très explicite. Il s'agit en fait de la possibilité de définir que toutes les tiles entre x et y sont affichées selon les tiles à partir de z. Vous saisissez? Prenons un exemple: mes objets utilisent les tiles de 0x400 à 0x500, et il n'y a rien entre 0x100 et 0x400. Ce serait bête de les remplir de tiles vides pour que la 0x400 contienne la tile voulue. Grâce aux conditions, je peux donc définir que toutes les tiles entre 0x400 et 0x500 sont affichées en utilisant les tiles à partir de 0x100. La tile 0x403 sera alors affichée 0x103.

Et cela fonctionne dans les deux sens: si vous sélectionnez ensuite la tile 0x103 dans votre tileset et la collez sur votre map, GBA Graphics inscrira automatiquement 0x403 à la place! Vous pouvez donc vous faire un tileset très varié et compact, contenant tous les graphismes et objets dont vous avez besoin, même si ceux-ci ont des valeurs très éloignées.

Les conditions sont écrites individuellement pour chaque fond, et vous pouvez en définir 20 au maximum pour chacun d'eux. Vous devez passer par la méthode AjCondition de l'objet Fonds. La syntaxe (assez spéciale) est la suivante:

Fonds[numéro_fond].AjCondition  tile_départ, tile_fin, nouvelle_valeur

Vous spécifiez donc le numéro de bloc de départ à affecter et le numéro de fin, ainsi que la nouvelle valeur que les blocs vont prendre. Pour effectuer l'opération désirée dans l'exemple ci-dessus, il faudrait écrire le code suivant:

Fonds[1].AjCondition 0x400,0x500 0x100

Vous pouvez encore spécifier que tous les blocs se trouvant dans une certaine gamme prenne une certaine valeur. Par exemple, si on veut que toutes les tiles entre 0xf000 et 0xffff soient affichées avec un point d'interrogation (tile 8 par exemple), on peut ajouter un caractère égal à la fin du dernier nombre:

Fonds[1].AjCondition 0xf000,0xffff 0x0008=

Options de conversion (scripté)

Ce chapitre est la suite de celui traitant des options de l'éditeur, Effets de couleurs et luminosité . Nous allons donc voir comment réaliser la même chose mais de manière scriptée. Cela vous permettra de paramétrer ces éléments pour chacune de vos conversions si vous souhaitez les scripter.

Voici un exemple de code démontrant l'utilisation de ces fonctions. Ce genre de code est généralement à insérer juste avant de lancer une conversion.

#On va utiliser 32 nuances (3*5 bits). C'est le mode par défaut.
   convert.nuances = 32
#Si votre couleur transparente (invisible) à vous est le vert RGB(0,255,0)...
   convert.couleurMasque = RGB(0,255,0)
#Changement de la méthode de réduction de couleurs
   convert.mode = optimal
#La fonction luminosite permet de modifier tous les paramètres d'un coup...
   convert.luminosite   gamma=1.3  add=10  alpha=-15%
#Dans ce cas, les autres paramètres (alpha et add) restent inchangés.
   convert.luminosite   gamma=1.0
#On peut définir tous ces paramètres individuellement pour chaque canal RVB...
   convert.luminosite   alpha=rgb(10%,20%,30%)

Scrolling parallaxe (scripté)

Vous pouvez appliquer un facteur de vitesse différent pour chacun des fonds. Je ne vais pas m'attarder sur ce sujet, car si cela vous intéresse, c'est vous savez déjà ce que c'est et comment vous en servir.

Dans GBA Graphics, c'est très simple; il y a un facteur en X et un facteur en Y. Ces facteurs sont des nombres flottants qui indiquent la vitesse, 1 étant la référence. Pour régler les facteurs, on doit utiliser la commande "VitesseDefil" de l'objet Fonds. La syntaxe est la suivante:
Fonds.vitesseDefil [numéroFond] valeurX, valeurY (réels)
Attention, vitesseDefil est bien un tableau, donc requiert l'utilisation d'un indice (numéro du fond)!

Aussi, n'oubliez pas que dans ce langage, les indices des tableaux commencent à un et non à zéro. Le fond numéro un est donc Fonds.vitesseDefil[1].
Un exemple concret: Fonds.vitesseDefil[2] 0.5,0.5
Ceci définira une demi-vitesse de défilement en x et en y.

Format du fichier de sauvegarde

Le format n'est plus binaire à présent, mais au format texte. Il fonctionne à peu près de la même manière que tous les autres fichiers de configuration (typiquement les .ini sous Windows et les .conf sous Linux), excepté pour la définition des éléments du projet qui est un peu spéciale et pas vraiment souple.
L'ancien format était vraiment mauvais, le nouveau vous fera certainement gagner de la place en mémoire, et la mise à jour depuis l'ancien format ne devrait pas poser de problème. Si toutefois c'était le cas, veuillez me le signaler. ;-)

Pour éditer le fichier (.pgg), utilisez le bloc-notes (notepad).
Le fichier est divisé en sections, ayant chacune une utilité et une syntaxe différente, bien que seule la section fichiers ne soit spéciale. Les sections sont définies par un .section nom_de_la_section en début de ligne, et sont les suivantes:

-Section infos: Cette section comprend les valeurs de certaines des variables internes lorsqu'elles ont été modifiées. Elle est écrite par GBA Graphics et ne devrait pas être éditée car son contenu ne sera pas sauvé (i.e. écrasé lors de la réécriture du fichier).
-Section fichiers: Cette section contient les fichiers, définis comme ci-dessous.
-Section données: Agit de la même manière que la section infos, sauf que vous pouvez y placer vos propres informations (ou commandes de script) sans qu'elles soient écrasées à la réécriture.

Le format de chaque élément dans la section fichier est le suivant:

    Elément: (nom court de l'élément)
    Type: (type, en lettres)
    Fichier: (fichier correspondant)
    Base: (élément de base, toujours une bitmap)
    Dossier: (dossier dans lequel il se trouve)

Il se peut que la ligne Dossier: soit absente, et dans ce cas, l'élément va dans le dossier par défaut suivant son type.

Le script

Le script est une fonction plutôt complexe, mais que j'ai tenté de simplifier le plus possible. Le but est de personnaliser votre environnement. Cependant, ce n'est pas un véritable langage de script, en ce sens qu'il ne gère pas l'utilisation de variables internes, boucles, et autres, car ça n'est pas vraiment utile. Prenez-le comme un fichier de configuration interactif et dynamique;
Par script, j'entends le fait de changer le comportement de GBA Graphics en exécutant diverses fonctions ou en modifiant certaines variables internes. Enfin vous verrez! :-p

Le fichier de script par défaut est script.spt mais il est modifiable en changeant la ligne Script = "script.spt" dans le fichier de configuration. Créez ensuite un fichier vierge (script.spt dans notre exemple) que vous placez bien sûr dans le répertoire du projet. Utilisez le bloc-notes pour éditer ce fichier, ou un autre éditeur du style.

Format des instructions

Chaque instruction prend une ligne, qui peut-être précédée d'autant d'espaces qu'on le désire. Elles sont terminées par un "#" ou un ";" (ce qui vient après est du commentaire) ou par un retour à la ligne.
Principalement, on distingue deux types d'instructions (c'est pas beaucoup, enfin bon); les assignements et les appels de fonctions. Comme je l'ai déjà dit, vous ne pouvez pas effectuer de manipulation de variables, boucles ou autres à l'intérieur du script, cependant vous assignez toujours des valeurs aux divers paramètres internes de GBA Graphics. Voici les diverses syntaxe que l'on peut adopter:

variable=1
variable=vrai
Fonction 1,2,3
Fonction "paramètre"

J'ai également le plus possible regroupé les variables dans des objets, comme en C++ ou en VB. Un objet peut contenir plusieurs variables (propriétés) et plusieurs fonctions (méthodes). Pour accéder à un élément quelconque qui se trouve dans un tableau, il suffit de mettre le nom de l'objet, un point, puis le nom de l'élément. Exemple, si je vous dis d'assigner 32 à la variable alphaGfx (qui se trouve dans l'objet Fonds), cela donnera:

Fonds.alphaGfx=32

Pour les fonctions, si je vous dis d'ajouter à l'éditeur le fond appelé "map_nv1", vous allez vous tourner vers la fonction Ajoute contenue dans l'objet Fonds et qui demande comme paramètre le nom de la map (entre guillemets), ça donnera donc:

Fonds.Ajoute "map_nv1"

Je sais, je n'explique pas très bien, mais en regardant des exemples de code concret, vous devriez vous en sortir car ce n'est pas trop compliqué. ;-)

Procédures et points d'entrée

Les points d'entrée du script sont définis comme les labels dans les autres langage. Néanmoins, il y a lieu de différencier trois types de points d'entrée (ou points de branchement):

-Labels: Les labels sont définis ainsi: "label:" sur une nouvelle ligne.
-Procédures: Ce sont comme les labels, sauf qu'on met un trait de soulignement au début du nom en plus. Exemple: "_procédure:". Le code qui se trouve en-dessous jusqu'à Fin sera donc exécuté lors du branchement à cette procédure.
-Evénements: Les événements sont des procédures automatiquement appelées par GBA Graphics lors de certaines circonstances, et peuvent être suivis d'un paramètre. Exemple: "OnOpen map_nv1:" sera appelé lors de l'ouverture de la map "map_nv1".

Les procédures sont exécutées droit en bas jusqu'à un Fin, Quitte ou un Retour, ayant chacun un effet différent. Voici les événements disponibles (il n'y en a pas beaucoup):

-OnStart: Cet événement est appelé au démarrage du programme.
-OnQuit: Cet événement est appelé lorsque vous quittez le programme.
-OnOpen map: Où map est le nom de la map qui est ouverte est appelée lorsque vous ouvrez l'éditeur de maps. Elle n'est pas appelée pour les maps qui sont ajoutées comme fond.
-OnSave map: Où map est le nom de la map qui est ouverte est appelée lorsque vous enregistrez la map en question.

Instructions standard

Il y a quelques instructions qui ont un effet générique. Les voici:

-Fin: Cette instruction se place seule sur une ligne et indique la fin d'une procédure. La lecture du script est alors arrêtée et le programme reprend la main.
-Quitte: Quitte le programme. Ne fonctionne que lors du traitement de l'événement OnStart.
-Goto label: Se branche directement à un label quelconque.
-Retour valeur: Arrête l'exécution du script et renvoie une valeur à GBA Graphics. Lorsque vous gérez les événements OnStart, OnQuit, OnOpen, retourner faux (0) interdit que la tâche ne se produise. Exemple:

OnStart:
    Retour 0

Interdit le démarrage du programme (pas très utile maintenant, mais peut le devenir surtout pour l'événement OnOpen pour interdire l'ouverture de certaines maps). Un bon exemple, en demandant à l'utilisateur s'il veut vraiment exécuter le programme et le quitte sinon:

OnStart:
    MsgBox "Voulez-vous vraiment exécuter le programme?","Petite question" sinon goto quitter
    #Cliqué sur Ok
    Retour 1
quitter:
    #Cliqué sur annuler
    Retour 0

Index du script

Cette section a pour but de présenter tous les paramètres, objets et fonctions disponibles depuis le script. N'oubliez pas que vous pouvez faire appel à l'invite de script (Ctrl+I) pour entrer rapidement des commande depuis le programme.

Variables

Cette section présente toutes les variables (paramètres) de GBA Graphics disponibles pour la modification, ainsi que leur type et une brève description. Lorsqu'une variable fait partie d'un objet, celle-ci sera précédée du nom de l'objet puis d'un point, comme si vous l'écriviez dans le script.
Les types disponibles prennent leur valeurs comme suit:

-Entier: Toute valeur entière, hexadécimale ou binaire. Les nombres en hexa sont précédés de 0x et les nombres binaires de 0b. Exemples équivalents:
Fonds.alphaHex=32
Fonds.alphaHex=0x20
Fonds.alphaHex=0b100000
-Booléen: Les booléens peuvent prendre la valeur vrai (1) ou la valeur faux (0). Exemples équivalents:
Fonds.visible[1]=vrai
Fonds.visible[1]=1
-Chaîne: Les chaînes contiennent du libre texte, délimité par les caractères suivants: guillemets ("Hello"), apostrophes ('Hello') ou étoiles (*Hello*). Normalement, on utilise les guillemets, mais si on veut également en utiliser dans la chaîne en question, ce ne sera pas possible. Par exemple: Exec ""Test.exe" document" ne marchera pas. En revanche, Exec *"Test.exe" document* fonctionne sans problème.
-Tableau: Les tableaux ont un type, comme les autres, excepté que leur nom est suivi d'un indice qui indique auquel des éléments du tableau vous voulez accéder. Exemple:
Fonds.visible[1]=faux
-Objets: Les objets sont suivis d'un point puis de la variable à laquelle vous voulez accéder. Chacune des variables a également son propre type.

Contrôle de la fenêtre

Depuis le script, vous pouvez également accéder aux contrôles Windows qui se trouve sur la page, ce qui vous permet de réaliser assez simplement des conversions automatisées.
Conseil: Utilisez les procédures pour automatiser la conversion des différents tileset et autres. Cela vous évitera de vous tromper et de bouziller votre projet...

Le principe de fonctionnement est le même que si vous le faisiez à la souris. Vous sélectionnez tel élément dans le projet, activez telle case à cocher, remplissez tel champ texte, et ainsi de suite. Bon, commençons par un petit exemple histoire de vous mettre dans le bain. Ce script définit le dossier par défaut pour les cartes ("Niveau 1") et lance la conversion des mosaïques.

_Conversion mosaïques:              #Procédure exportée
  Dossiers.cartes="Niveau 1"        #Dossier pour les cartes
  arbre-mosaiques.Select            #Sélectionne "Mosaïques" dans le projet
  texte-source="test.bmp"           #Définit la source
  texte-tileset="essai.til.c"       #Le tileset
  texte-palette="essai.pal.c"       #La palette
  texte-map="essai.map.c"           #La map
  combo-taille="256x256"            #Taille de la map
  combo-tiles="16x16"               #Taille des tiles
  check-16=vrai                     #Mode 16 couleurs
  Ok                                #Ok -> lance la conversion
  Fin                               #Procédure terminée

Ce n'est pas trop compliqué à comprendre... Voici les types d'éléments que vous pouvez modifier (et les valeurs à leur donner):

-Arbre: Désigne un des éléments de l'arbre du projet. Seuls les dossiers de base sont accessibles. Il n'y a aucun assignement à faire, vous devez juste faire appel à la fonction membre Select pour le choisir (même si ce n'est pas vraiment obligatoire). Exemple:
arbre-bitmaps16.Select
-Texte: Désigne une zone de texte à remplir. Le type accepté est bien entendu une chaîne de caractère. Exemple:
texte-source="image.bmp"
-CheckBox: On aurait pu s'attendre à ce que les cases à cocher demandent des booléens. Or, il n'en est rien. Même si le type booléen fonctionne dans la plupart des cas, c'est le type entier qu'il faudra utiliser si vous voulez pouvoir mettre l'état grisé à ces cases. Les états que ces cases peuvent prendre sont les suivants:
0 (faux): Désactivée
1 (vrai): Activée
2: Indéterminé (grisée)
Deux petits exemples équivalents:
check-palette=vrai
check-palette=1
-Radio: Les boutons radio sont les petits boutons ronds, groupés, vous permettant de choisir entre plusieurs options, car un seul ne reste actif à la fois. Ici, le type est bien le booléen. Exemple:
radio-rotation=vrai
-ComboBox: Les zones de liste déroulante acceptent bien entendu le type chaîne. Vous devez leur fournir une chaîne qui fasse partie de leur liste sinon votre instruction n'aura aucun effet.
combo-taille="1024x1024"

Voici à présent une liste des contrôles accessibles, avec leur type et une description.

Le mieux est de faire des essais pour voir ;-)

Appels de fonctions

Si vous avez compris les autres sections, je pense que ce ne sera pas un problème. Les fonctions, contrairement aux assignements comme vus plus haut, effectuent généralement des opérations plus complexes. Par exemple, on aura une fonction pour ajouter un fond à l'éditeur. Et cela ne se résoud pas à un simple assignement, je peux vous le dire! Cependant, grâce aux fonctions et leur utilisation dans le script, c'est tout comme.

Mais souvenez-vous, lorsque vous effectuez des assignements (comme fonds.alphaGfx=32), vous devez bien savoir à l'avance quelle valeur vous allez lui donner... eh bien pour les fonctions, c'est la même chose, il faut bien lui dire qu'est-ce que vous voulez faire! Par exemple, dans le cas de l'ajout d'un fond, il faudra lui dire le nom du fond vous voulez ajouter. On appelle cela des arguments.

Les arguments suivent le nom de la fonction à appeler et sont séparés par des virgules (eh oui il peut y en avoir plusieurs, même si c'est plutôt rare ici). On définit donc le format des appels de fonctions ainsi (et on appelle cela un prototype):

Objet.Fonction arg1,arg2,...

Où l'objet est bien entendu facultatif, mais la plupart des fonctions sont tout de même regroupées dans des objets. Voici à présent les fonctions disponibles, ainsi que les objets dans lesquels elles se trouvent et une brève description, sans oublier les arguments qu'elle demande.

Pour la commande Exec, un petit exemple s'impose! :-)

 Exec *"Compresse.exe" map_nv1.map.c GH1.map.c mapGfxCour*

Voilà, c'est tout. J'espère que cela n'aura pas été trop indigeste! Si vous avez des questions, veuillez les poser sur le forum de playeradvance.
Merci d'advance! :-D

License

Vous pouvez utiliser ce programme gratuitement et librement pour une utilisation non-commerciale. Si vous voulez en faire une utilisation commerciale, contactez-moi.
Vous pouvez également le copier et le distribuer sans problème tant qu'il n'est pas modifié (peut-être que je le mettrai en GPL un de ces quatre).
Je ne suis pas responsable de l'utilisation que vous faites de ce logiciel, ni des problèmes qu'il pourrait engendrer! Utilisez-le à vos propres risques!
Egalement, si vous distribuez le programme, incluez ce présent fichier d'aide. Vous pouvez ainsi inclure le programme au dossier de ressources de votre projet et distribuer le tout sans problème.

Pour me contacter: f.bron@isuisse.com