Créer ses propres émoticones

Dans ce tuto je vais vous expliquez comment modifier les émotes de manière assez poussée. Donnant même des résultats qui n’ont plus rien à voir avec ce qu'on peut appeler "émote". (allez voir à la fin du tuto pour vous faire une petite idée).
Attention, je ne vais pas vous apprendre comment modifier une image (avec NSE ou un autre logiciel), ni les bases de l'hexa.

Pour ceux qui ne voit pas ce que sont les émotes, c'est ça : ?,!,!!,^^,X. Ils sont utilisable dans les applyMovements (#raw 61 à #raw 66).
Malheureusement je n'ai pas encore réussi à augmenter le nombre d'émotes disponible, donc pour le moment il faudra se limiter à 5 (2 pour RSE). Mais j'y travaille.

Les nombres précédés d'un '#' sont en hexadécimal, sinon ils sont en décimal.

La liste d'images

Elle permet de lister l'ensemble des images qui pourront être utilisées dans les émotes. Dans se tuto je part du principe que vous voulez créer un tout nouveau smiley sans réutiliser les images des anciens émotes, donc ce n'est pas la peine de toucher à la liste déjà existante, on va en créer une nouvelle.

Avant même de créer cette liste je vous laisse insérer les images que vous allez utiliser. Je ne donne pas de détails là-dessus, c'est très simple. (notez les offsets, on en aura besoin)
Malheureusement la palette est la même que celle du personnage ce qui limite énormément les possibilités que nous offre ces "émotes", mais je vais essayer de palier à ce problème.

Où crée notre liste

Chaque image prendra 8 octets dans la liste, il vous faut donc trouver un espace dans la ROM avec une taille suffisante. (notez l'offset auquel vous commencez la liste)

A partir de maintenant, j'ai décidé d'illustrer chaque étape avec un exemple qui sera de couleur grise. Personnellement j'ai décidé que mon "émote" contiendrait 9 images, que j'ai déjà insérées. Ma liste aura alors une taille de 9*8 = #48 octets. J'ai choisi de créer ma liste en commençant à l'offset #BF0000 pour avoir largement la place.

Le re-pointage

Avant même de créer notre animation on va s'attaquer au re-pointage, c'est simple et sa évitera de perdre l'offsets.

Il faut remplacer le pointeur à cette offset par celui de l'offset à partir duquel va débuter votre nouvelle liste. (celui que vous venez de noter)

Dans mon exemple, ce sera 00 00 BF 08.

Créons notre propre liste

On va enfin s'attaquer à cette liste, rendez vous à l'offset que vous avez choisis.
Chaque image se présente sous la forme suivante :

XX XX XX 08 est le pointeur sur l'image.
YY YY dépend de la taille de l'image. (Plus d’explication dans la partie sur les dimensions)

Le XX XX XX ne devrait pas vous posez de problème. Il s'agit de l'offset de l'image en little-endian (inversé).
Pour le YY YY, voici ce qu'il faut mettre en fonction de la taille de votre image : 16*16 = 80 00 ; 32*32 = 00 02; 64*64 = 00 08.

Et vous reproduisez ce schéma pour chaque image. Ce qui donnera quelque-chose sous la forme :

Personnellement, j'avais inséré ma première image à l'offset #B00000 et la seconde à l'offset #B00200. Toutes mes images sont en 32*32.
J'obtiendrai donc la liste suivante :

L'ordre dans lequel vous mettez les images dans la liste n'a pas d'importance, mais je vous conseille quand même de les mettre dans le même ordre que celui dans lequel elles seront affichées, ça vous simplifiera la tache pour la suite.

Et voilà, on a enfin terminé cette liste.

Les animations

Mais dire au jeu où se trouvent nos images n'est pas suffisant, il faut aussi lui dire dans quelle ordre afficher ces images. C'est à ça que servent les "animations".

Où crée son animation

Avant toute chose il faut choisir où insérer notre animation dans la ROM, chaque étape est codée sur 4 octets et 2 autres octets sont nécessaire pour marquer la fin de l'animation. Faite donc en sorte d'avoir assez de place. (notez l'offsets auquel débute votre animation).

Souvenez-vous, j'avais 9 images pour composer mon "émote", mais mon animation sera plus longue car je choisis d'afficher plusieurs fois certaines images, mon animation ressemblera à sa: img1 - img2 - ... - img8 - img9 - img5.
J'ai alors un total de 10 étapes. Donc il faut que je prévois un espace avec au moins 10*4+2= #2A octets disponibles. Encore une fois je prend large et je choisis de commencer à l'offset #BF1000.

Le re-pointage

Encore une fois on va s'attaquer au re-pointage avant même de crée notre animation.

Il y a en faite 5 pointeurs différents (2 pour RSE), alors comment savoir lequel modifier, et bien en faite ça dépend de vous, il y a un pointeur pour chaque "émote" et ils sont dans l'ordre des raws, donc le premier pointeur correspond au #raw 61, le second au #raw 62, etc.

Moi j'ai envie que mon animation soit appelée quand j'utilise l'instruction #raw 62, je vais donc modifier le second pointeur (offset: #3C 16 F0) en #0001BF08.

Créons notre animation

On va enfin pouvoir s'attaquer à cette animation. Chaque étape de l'animation peut être défini par 3 paramètres: l'image à afficher, sa durée, et le split à appliquer.

La structure pour chaque étape de l'animation est la suivante :

XX est l'indice de l'image dans la liste que l'on a créer au début, d’où l'importance de ne pas mettre les images dans n'importe quelle ordre. Attention on commence à l'indice 0 et non à l'indice 1.
YY correspond en faite à plusieurs informations. Pour les obtenir il faut le mettre sous la forme binaire (je donnerais pas d’explication sur cette conversion, ce n'est pas le but du tuto):

D'abord les WWWWWW, il s'agit en faite de la durée pendant laquelle l'image doit être affichée, en frame (sachant que la gba à une fréquence de 60 image/s).
Le premier bit (U) correspond au split horizontal. 0 = pas de split ; 1 = split.
Le second bit (V) correspond au split vertical. 0 = pas de split ; 1 = split.

Remarque :
1 - Si aucun split n'est à appliquer contentez vous de mettre le nombre de frame directement en hexa, pas besoin de passer par le binaire.
2 - Le nombre maximum de frame est #3F (63), donc si vous voulez que votre image reste affichée plus longtemps il faudra faire plusieurs étapes avec la même image à la suite.

La première étape de mon animation sera la première image de la liste (donc indice 0), et sera affichée pendant 10 frames, sans split vertical n'y horizontal. Elle sera donc codée comme suit :

Il me suffit alors de mettre le code de chaque étape à la suite et de finir par #FFFF pour avoir mon animation, on aura quelque chose sous la forme :

Pour moi ce sera :

Et voilà, notre animation est terminée. Si vous avez gardé les dimensions par défaut vous pouvez déjà admirer votre création. Pour les autres ça continue, mais rassurez-vous, c'est presque fini.

Les dimensions

Les images en 16*16 c'est gentil mais a part de simple "émote" ça permet pas de faire grand chose, mais il est possible d'augmenter ces dimensions pour avoir du 32*32 ou encore du 64*64.

Mais attention, il y a une contrainte très importante, toute les images doivent avoir la même dimension, sans exception.

Les dimensions de l'image à afficher

L'octet à cette offset correspond aux dimensions des "émotes", il se présente sous la forme: X0 suivit de 00 04. Il vous suffit de remplacer le X par la valeur correspondant à vos dimensions: 4 pour 16*16 ; 8 pour 32*32 ; C pour 64*64.

La quantité de donnée à mettre en mémoire

En faite vous n'aurez ici plus rien à modifier, vous avez donc fini ce tuto. Mais j'estime qu'une explication sur ce point pouvait vous être utile pour mieux comprendre certains points (pas uniquement en rapport avec ce tuto).

Le titre peut vous paraître flou mais en faite vous avez sans le savoir déjà dit au jeu quelle quantité de données mettre en mémoire, et oui c'était dans la partie sur comment créer sa liste, je vous avez dis que YY YY dépendais des dimensions de l'image sans donnéer plus de détaille.
Et bien ce YY YY (en little ediant) correspond à la quantité de données mis en mémoire. Et plus précisément la quantité d'octet à mettre en mémoire. Par exemple pour une image en 16*16 : 16*16 = 256 pixels, mais comme chaque octets code 2 pixels on divise par 2, soit 256 / 2 = 128 = #40.
En théorie, un nombre YY YY très grand donnerait toujours le bon résultat visuel car suffisamment de donnée serait en mémoire. Mais la mémoire est limitée donc on risque d’empiéter sur d'autres données en mémoire (et c'est ce qui arrive si YY YY est trop grand).
Vous pouvez essayer de faire varier YY YY et d'observer ce qui se passe en mémoire avec VBA (Tool->map) pour mieux comprendre ce que je tente d’expliquer.

Quelques exemples d'utilisation

Avant de vous quittez voici quelque exemples d'utilisation possibles de ces "émotes" offrant des possibilités scénariste vraiment sympa :
- Voir le rêve d'un personnage.
- Illustrer les propos d'un personage avec une petite animation.
- Faire parler les personnage à travers de petites bulles (Comme volucité dans N/B)
Une petite vidéo de ce que j'ai pu obtenir sans trop d'effort :

Pour toutes questions ou suggestions, dirigez-vous vers le topic dédié sur le forum.

Par Unifag