Forum TI-Planet.org

Bonjour,

Je voudrais programmer en C sur ma TI-89 Titanium et faire une (tile)map. J'ai regardé un peu le code de Zelda, mais le résultat était catastroph moche .
Est-ce que quelqu'un pourrais me dire concrètement comment faire une map et des sprites en C?
J'ai déjà téléchargé TIGCC.

Merci!

Pour TI-68k, les deux seules librairies graphiques maintenues sont ExtGraph ( https://github.com/debrouxl/ExtGraph ) et Genlib ( http://www.yaronet.com/t3 ). Les deux comprennent des exemples :
Pour TIGCC, bien que la dernière release officielle soit 0.95, elle est sauvagement dépassée: utilise au minimum la version 0.96 Beta 8 (qui date de plus de 4 ans). Ou utilise GCC4TI 0.96 Beta 10 (téléchargeable notamment sur TI-FR - tiens, ça me fait penser qu'il pourrait être utile de l'uploader sur TI-Bank, que je ne fréquentais pas au moment où cette version a été releasée), qui a moins de bugs et un peu plus de features et optimisations.

Pour te faire des sprites, tu peux faire comme ça, par exemple : (tiré de mon jeu de palet)

Code: Select all

static BITMAP balle =
    {
        5, 5,
        {
            0b01110000,
            0b11111000,
            0b11111000,
            0b11111000,
            0b01110000,
        }
    };

Il faut rappeler l'image par un pointeur dans une fonction du type BitmapPut.

Si tu veux coder des images plus complexes, utilise istudio qui permet aussi d'exporter une image en hexa pour l'inclure dans un code en C !

Sinon, un sprite c'est juste un tableau d'entiers, où chaque bit représente 1 pixel, s'il vaut 1 le pixel est allumé, sinon c'est que le pixel est éteint.
Il y a grosso-modo 3 types de sprites, cela dépend de la largeur du sprite (la hauteur étant potentiellement illimitée) : on utilise généralement des unsigned char pour des sprites de largeur unsigned short pour des sprites de largeur unsigned long pour des sprites de largeur Concrètement, pour créer un sprite, il suffit de faire un tableau d'entiers où chaque entier représentera une ligne du sprite, par exemple :

unsigned char mon_sprite[] = {
0b00111100,
0b01000010,
0b10000001,
0b10000001,
0b10000001,
0b10000001,
0b01000010,
0b00111100
};


Cela crée le sprite, qui est un ovale ici
Ensuite pour l'afficher, il faut utiliser la fonction SpriteX, avec X valant 8,16 ou 32 (selon la largeur), et qui s'utilise de la façon suivante :


SpriteX(xpos, ypos, height, screen, attr);

xpos : Position x où placer le sprite
ypos : Position y où placer le sprite
height : Hauteur du sprite (nombre de lignes, ici
screen : Un pointeur pour indiquer sur quel écran afficher, utile si tu veux utiliser par exemple des buffers
ou des écrans virtuels pour ne pas afficher tout de suite à l'écran, pour l'instant tu peux mettre LCD_MEM ça suffit.
attr : Comment afficher le sprite (Normal, inversé, xor etc ...)


Le code complet sera donc :

#include

void _main(void)
{
unsigned char mon_sprite[] = {
0b00111100,
0b01000010,
0b10000001,
0b10000001,
0b10000001,
0b10000001,
0b01000010,
0b00111100
};

// Notre sprite fait moins de 8 pixels de largeur, on l'affiche à l'écran
Sprite8(50, 50, 8, LCD_MEM, A_NORMAL);
}


Sinon, il y a les bibliothèques (haha Lionel t'as fait la faute ) extgraph et genlib qui offrent des fonctions similaires, plus rapides, réfères-toi à la doc si tu veux en savoir plus.

Oui, il est très fortement conseillé d'utiliser Genlib ou ExtGraph pour gérer des maps, toutes les fonctions sont déjà écrites et optimisées, un must, vraiment incontournable pour un jeu utilisant des maps à mon avis.

Pour les sprites, Istudio est très bien, mais il y a aussi DoAnyBgs de Ximoon qui est très bien aussi (et qui exporte si on veut au format Genlib, fort commode).

tama, ton bloc de font monospaced ruine la lisibilité de la page :;):

Il faut rappeler l'image par un pointeur dans une fonction du type BitmapPut.

Si c'est un programme où il est acceptable que le dessin soit lent (type jeux de réflexion), oui. Sinon (et ça risque d'être le cas ici, vu qu'il mentionne un tilemap), c'est fortement déconseillé: mieux vaut éviter toutes les fonctions graphiques d'AMS quand il y a besoin de vitesse :

si tu veux plus il faudra sûrement utiliser des Bitmap comme le suggère loulou54

Pas nécessairement: ExtGraph et Genlib proposent toutes les deux (du moins, pour Genlib, il me semble) des fonctions de sprites d'une largeur multiple de 8 pixels. Nettement plus rapides que celles d'AMS, bien sûr.

Hm je me suis trompé dans la formulation : -sûrement +peut-être

EDIT : ceci dit, ta remarque est tout à fait valable

 

Show/Hide spoilerAfficher/Masquer le spoiler

Sinon, un sprite c'est juste un tableau d'entiers, où chaque bit représente 1 pixel, s'il vaut 1 le pixel est allumé, sinon c'est que le pixel est éteint.
Il y a grosso-modo 3 types de sprites, cela dépend de la largeur du sprite (la hauteur étant potentiellement illimitée) : on utilise généralement des unsigned char pour des sprites de largeur unsigned short pour des sprites de largeur unsigned long pour des sprites de largeur Concrètement, pour créer un sprite, il suffit de faire un tableau d'entiers où chaque entier représentera une ligne du sprite, par exemple :

unsigned char mon_sprite[] = {
0b00111100,
0b01000010,
0b10000001,
0b10000001,
0b10000001,
0b10000001,
0b01000010,
0b00111100
};

Merci.
On peut pas faire ça avec de l'hexadécimal?

Si, l'hexa est accepté, et il est plus standard que le binaire (mais moins lisible pour l'édition directe dans les sources) :

Yep, tu peux faire avec de l'hexa en mettant "0x" à la place de "0b", j'ai mis en format binaire pour faire plus lisible, tu peux même mettre directement en décimal (60 pour la première ligne par exemple), mais si tu veux retoucher ton sprite plus tard ce sera plus difficile à faire (perso je préfère la forme hexa)