Ca me dérange pas du tout d´aider au contraire 
Bon je suppose que tu veux programmer des applications graphiques sur 89, aussi je vais te faire une petite présentation des fonctions et techniques mise en oeuvre pour y parvenir.
J´espère que tu sais ce qu´est un pointeur, car sinon tu ne comprendra pas tout au début.
L´écran
Déjà il est important de noter que ses dimensions sont de 160x100 sur ti89.
Bon ca c´est plus pour ta culture personnelle qu´autre chose, mais tu peux accéder à n´importe quel pixel de l´écran de ta 89 en accédant au buffer écran, un espace mémoire réservé qui renferme l´état de chaque pixel de l´écran.
Celui-ci se trouve à l´addresse 0x4C00, mais pour éviter de t´en rappeler, utilise LCD_MEM.
Petit exemple tout bête pour voir le truc :
- include < tigcclib.h>
void _main(void)
{
char *bufferEcran = LCD_MEM; / / Pointeur vers l´écran
*bufferEcran = 0; / / On met le premier octet à 0
ngetchx(); / / Attends la pression d´une touche
}
Bon alors comme je l´ai dit avant, cela peu sembler bizarre pour un débutant, mais reviens y après si tu ne suis pas.
Ce que l´on fait simplement, c´est de mettre à zero le premier octet du buffer écran grâce à un pointeur vers celui-ci.
Comme l´écran est en noir et blanc, 1 octet = 8 bits = 8 pixels.
Enutilisant *(bufferEcran+1) = 0;, on effacerait les 8 pixels suivant et ainsi de suite ( tu verra pourquoi plus tard dans le chapitre sur l´arithmétique des pointeurs).
C´était juste une introduction pour que tu aie quelques notions. Si ta rien compris c´est normal au début, reviens y après avoir lu le livre ou un tuto car j´emploie déjà quelques notions un peu avancées.
( Note encore plus avancée : le buffer écran à la même dimension sur 89, 92, 92+, V200, puisque le système est le même, ce qui veut dire que ton écran virtuel de 89 est plus grand que l´écran réel. Cela permet quelques supercheries comme l´implantation d´un scrolling ultra-rapide en C, mais on verra plus tard )
Heureusement pour nous simplifier grandement la tâche viennent les :
Fonctions graphiques
Dans ce domaine là, TIGCC est très complet puisqu´il t´offre des fonctions pour faire a peu près ce que tu veux avec l´écran.
( Note: Généralement à la création d´un nouveau projet, TIGCC inclut par défaut tout les fichier . h nécessaire ( #include < tigcclib.h>), je te donne le nom des . h juste pour que tu sache ou ca se trouve, pour aller voir dans l´aide notament )
graph.h renferme toute les fonctions de base permettant de tracer des lignes, des cercles, des carrés, etc . ..
Exemple :
DrawLine( 10, 10, 20, 20, A_NORMAL ) ;
Va te tracer un ligne en tre les pixels de coordonné ( 10,10) et ( 20,20) à l´écran.
A_NORMAL spécifie le mode de tracage. Va voir dans l´aide pour plus d´infos. Tu peux nottament tracer en inversant les pixels ( XOR).
Pour écrire du texte, il y a :
DrawStr( 0, 0, " Hello, world ! ", A_NORMAL ) ;
Cependant j´ai tendance à utiliser la fonction :
printf_xy( 10, 10, " Hello, world ! " ) ;
Puisqu´elle permet de formater directement lors du passage d´arguments.
Et il y en a comme ca plein d´autres, va voir la doc, rubrique " Header Files", " graph.h" pour plus d´infos ( en anglais, mais programmer en C, c´ets quasi-obligatoirement passer par l´anglais ) .
Pour faire des jeux et afficher des images, il y a également :
Les sprites
( voir sprite.h)
Diponible en 3 version : Sprite8, Sprite16, Sprite32 pour des sprites de respectivement 8xZ, 16xZ, 32xZ ( ou Z est un nombre quelconque), ces fonctions permettent simplement d´afficher rapidement une image constituée de plusieurs octets.
Démontronstration :
On inclut les libs tout d´abord :
- include < tigcclib.h>
Ensuite on va définir notre sprite. On va en faire un de 8x8. Pour ce faire, on va avoir besoin d´un tableau de 8 octets ( 1 octet = 8 bits et dons 8 pixels je rappelle). Ainsi, chaque octet représentera une ligne de 8 pixels qui représentera notre image.
Petite note : peut être ne le sais tu pas encore, mais en C, on peut représenter les nombres en plusieures base : 10, 8 ( octale) et 16 ( hexadécimale).
Exemple :
10 ( base 10) = 0xF ( base 16)
16 ( base 10) = 0x10 ( base 16) . ..
La 89 peut te faire ces conversions.
L´avantage de l´héxadécimal, c´est que cela permet de représenter facilement 2 octets : 0xFF est plus concis que 255.
La 89 permet en plus l´emploi du type binaire, noté 0b... Cela permet de représenter facilement des sprites, notament :
unsigned char image[8] = {
0b10000001,
0b01000010,
0b00100100,
0b00011000,
0b00011000,
0b00100100,
0b01000010,
0b10000001 };
Ca représente une croix.
Viens ensuite notre fonction main :
void _main( void )
{
clrscr(); / / Efface l´écran
Sprite8( 10, / / Coordonnée x
10, / / coordonnée y
8, / / Hauteur de l´image ( la notre : 8 car 8x8)
image, / / Notre image
LCD_MEM, / / L´écran
SPRT_OR ) ; / / Le mode
ngetchx(); / / Attends la pression d´une touche
}
Et voila, cela affiche notre sprite en forme de croix à l´écran.
Bon l´ensemble des concepts énoncés ici sont peu abordables pour un débutant, le mieux est que tu commence à lire le livre ou un tuto afin de voir au moins le fonctionnement des tableaux/pointeurs avant de vouloir te lancer dans les techniques énoncées si dessus.
Cela peut sembler difficle au début, mais une fois que c´est compris on peut faire de chouettes choses , nottament en utilisant des graphismes en niveaux de gris.
Les commandes de graph.h ne sont pas difficiles à comprendre, mais celle de Sprite.h réclament plus de connaissance : laisse les tomber si cela t´es obscur pour le moent.
Je te conseille également de parcourir les exemple de codes que tu trouveras dans le répertoire de TIGCC : ils abordent de nombreux concepts de la programmation ti89.
A mon avis, la programmation en C sur ti constitue l´une des meilleures formations qui soit pour s´initier au C et à sa puissance puisque cette machine te permet un accès direct à son hardware par les pointeurs et présente l´avantage de ne pas être trop complexe, tout en possédant les mécanismes de fonctionnement similaires à un ordinateur.
Te décourages pas si tu galères au début, c´est normal
Je reste là pour répondre à tes questions.
