UWORD chip donnees_vsprite[]=
  {
    0x0FF0, 0x0FF0,
    0x0FF0, 0x0FF0,
    0x0FF0, 0x0FF0,
    0x0FF0, 0x0FF0
  };

  struct VSprite tete, queue, vsprite;

struct VSprite
{
  struct VSprite *NextVSprite;
  struct VSprite *PrevVSprite;
  struct VSprite *DrawPath;
  struct VSprite *ClearPath;

  WORD OldY, OldX;
  WORD Flags;
  WORD Y, X;
  WORD Height;
  WORD Width;
  WORD Depth;
  WORD MeMask;
  WORD HitMask;
  WORD *ImageData;
  WORD *BorderLine;
  WORD *CollMask;
  WORD *SprColors;
  struct Bob *VSBob;
  BYTE PlanePick;
  BYTE PlaneOnOff;
  VUserStuff VUserExt;
};

  WORD table_couleur[] = { 0x000F, 0x00F0, 0x0F00 };

  struct GelsInfo ginfo;

struct GelsInfo
{
  BYTE sprRsrvd;
  UBYTE Flags;
  struct VSprite *gelHead, gelTail;
  WORD *nextLine;
  WORD **lastColor;
  struct collTable *collHandler;
  short leftmost, rightmost, topmost, bottommost;
  APTR firstBlissObj, lastBlissObj;
};

  WORD prochaine_ligne[8];
  WORD *dernieres_couleurs[8];

  /* Tous les sprites exceptés les deux premiers peuvent servir de VSprites: */
  ginfo.sprRsrvd = 0xFC;

  ginfo.nextLine = prochaine_ligne;
  ginfo.lastColor = dernieres_couleurs;

 /* Transmet la structure GelsInfo au système: */
 InitGels( &tete, &queue, &ginfo );

 /* Transmet au Rastport un pointeur sur la structure GelsInfo: */
 my_window->RPort->GelsInfo = &ginfo;

vsprite.X = x;              /* Donne les positions en X et Y. */
vsprite.Y = y;
vsprite.Height = 16;        /* Fixe la hauteur à 16 lignes.   */
vsprite.Width = 2;          /* Fixe la largeur à 2 mots.      */
vsprite.Depth = 2;          /* Fixe la profondeur à 2 plans.  */
vsprite.Flags = VSPRITE;    /* Nous voulons un VSprite.       */
vsprite.SprColors = table_couleurs;  /* Pointeur sur la table de couleurs */
vsprite.ImageData = donnees_vsprite; /* Pointeur sur les données graphiques */

  AddVSprite( &vsprite, my_window->RPort );

  SortGList( my_rastport );
  DrawGList( my_rastport, my_viewport );
  MrgCop( my_view );
  LoadView( my_view );

  SortGList( my_window->RPort );
  DrawGList( my_window->RPort, &(my_screen->ViewPort) );
  MakeScreen( my_screen );
  RethinkDisplay();

  RemVSprite( &vsprite );

/* Exemple 1                            */
/* Cet exemple montre comment obtenir et utiliser un VSprite. Le  */
/* VSprite peut être déplacé par l'utilisateur grâce aux flèches. */

/* Comme nous utilisons Intuition, nous incluons ce fichier : */
#include <intuition/intuition.h>

/* Nous incluons ce fichier puisque nous utilisons les sprites : */
#include <graphics/gels.h>

/* Déclare les fonctions que nous allons utiliser : */
void main();
void nettoie();

struct IntuitionBase *IntuitionBase = NULL;
/* Nous devons ouvrir la bibliothèque Graphics puisque nous utilisons les sprites : */
struct GfxBase *GfxBase = NULL;

/* Déclare un pointeur sur une structure Screen : */ 
struct Screen *mon_ecran;

/* Déclare et initialise notre structure NewScreen : */
struct NewScreen mon_nouvel_ecran=
{
 0,             /* LeftEdge 	Doit toujours être égal à 0. */
 0,             /* TopEdge  	Sommet de l'écran.*/
 640,           /* Width   	Nous utilisons un écran haute résolution. */
 200,           /* Height  	Affichage NTSC (américain) non entrelacé. */
 2,             /* Depth   	4 couleurs. */
 0,             /* DetailPen 	Le texte sera affiché avec la couleur du registre 0. */
 1,             /* BlockPen 	Les blocs seront affichés avec la couleur du registre 1. */
 HIRES|SPRITES, /* ViewModes    Haute résolution, les sprites vont servir. */
 CUSTOMSCREEN,  /* Type         Votre écran personnalisé. */
 NULL,          /* Font   	Police de caractères par défaut. */
 "VSprites!",   /* Title        Nom de l'écran. */
 NULL,          /* Gadget  	Doit pour le moment être à 0. */
 NULL           /* BitMap  	Pas de Custom BitMap. */
};


/* Déclare un pointeur sur une structure Window : */ 
struct Window *ma_fenetre = NULL;

/* Déclare et initialise notre structure NewWindow : */
struct NewWindow ma_nouvelle_fenetre=
{
 0,             /* LeftEdge    Position en X de la fenêtre. */
 0,             /* TopEdge     Position en Y de la fenêtre. */
 640,           /* Width       Largeur 640 pixels. */
 200,           /* Height      Hauteur 200 lignes. */
 0,             /* DetailPen   Le texte sera affiché avec la couleur du registre 0. */
 1,             /* BlockPen    Les blocs seront affichés avec la couleur du registre 1. */
 CLOSEWINDOW|   /* IDCMPFlags  La fenêtre nous enverra un message si */
 RAWKEY,        /*             l'utilisateur a sélectionné le gadget de */
                /*             fermeture ou s'il a pressé une touche. */
 SMART_REFRESH| /* Flags       Intuition doit rafraîchir la fenêtre. */
 WINDOWCLOSE|   /*             Gadget de fermeture. */
 WINDOWDRAG|    /*             Gadget de déplacement. */
 WINDOWDEPTH|   /*             Gadgets de profondeur. */
 WINDOWSIZING|  /*             Gadget de taille. */
 ACTIVATE,      /*             La fenêtre doit être activée à son ouverture. */
 NULL,          /* FirstGadget Pas de gadget spécial (custom). */
 NULL,          /* CheckMark   Utilise le CheckMark d'Intuition. */
 "Utilisez les flèches pour déplacer le VSprite!", /* Titre */
 NULL,          /* Screen      Sera reliée plus tard à un écran personnalisé (custom screen). */
 NULL,          /* BitMap      Pas de Custom BitMap. */
 80,            /* MinWidth    Nous n'autoriserons pas que la fenêtre */
 30,            /* MinHeight   devienne plus petite que 80x30, ni */
 640,           /* MaxWidth    plus grande que 640x200. */
 200,           /* MaxHeight */
 CUSTOMSCREEN   /* Type        Relié à l'écran du Workbench. */
};


/* 1. Déclare et initialise des données */
/*  de sprite pour chaque VSprite:  */
UWORD chip donnees_vsprite[]=
{
 0x0180, 0x0000,
 0x03C0, 0x0000,
 0x07E0, 0x0000,
 0x0FF0, 0x0000,
 0x1FF8, 0x0000,
 0x3FFC, 0x0000,
 0x7FFE, 0x0000,
 0x0000, 0xFFFF,
 0x0000, 0xFFFF,
 0x7FFE, 0x7FFE,
 0x3FFC, 0x3FFC,
 0x1FF8, 0x1FF8,
 0x0FF0, 0x0FF0,
 0x07E0, 0x07E0,
 0x03C0, 0x03C0,
 0x0180, 0x0180,
};


/* 2. Déclare trois structures VSprite. Une servira, les deux autres sont factices: */
struct VSprite tete, queue, vsprite;


/* 3. Décide des couleurs du VSprite : */
/*             RGB   RGB   RGB */
WORD table_couleur[] = { 0x000F, 0x00F0, 0x0F00 };


/* 4. Déclare une structure GelsInfo : */
struct GelsInfo ginfo;


/* Cette variable booléenne nous indiquera si le VSprite fait partie de la liste ou non: */
BOOL vsprite_on = FALSE;


/* Ce programme n'ouvrira pas de fenêtre console si exécuté à partir du Workbench, mais nous n'écrirons */
/* donc rien. Des fonctions comme printf() ne devront donc pas être utilisées. */
void _main()
{
 /* La structure GelsInfo a besoin des tableaux suivants: */
 WORD prochaine_ligne[ 8 ];
 WORD *dernieres_couleurs[ 8 ];

 /* Position du sprite: */
 WORD x = 40;
 WORD y = 40;

 /* Direction de déplacement du sprite : */
 WORD x_direction = 0;
 WORD y_direction = 0;

 /* Variable booléenne utilisée pour la boucle while: */
 BOOL ferme_moi = FALSE;

 ULONG class; /* IDCMP */
 USHORT code; /* Code */

 /* Déclare un pointeur sur une structure IntuiMessage : */
 struct IntuiMessage *mon_message;


 /* Ouvre la bibliothèque Intuition : */
 IntuitionBase = (struct IntuitionBase *)
  OpenLibrary( "intuition.library", 0 );
 
 if( IntuitionBase == NULL )
  nettoie(); /* N'a pas pu ouvrir la bibliothèque Intuition ! */


 /* 5. Ouvre la bibliothèque Graphics :          */
 /* Puisque nous utilisons des sprites nous avons besoin d'ouvrir la bibliothèque Graphics : */
 GfxBase = (struct GfxBase *)
  OpenLibrary( "graphics.library", 0);

 if( GfxBase == NULL )
  nettoie(); /* N'a pas pu ouvrir la bibliothèque Graphics ! */


 /* Nous allons maintenant essayer d'ouvrir l'écran : */
 mon_ecran = (struct Screen *) OpenScreen( &mon_nouvel_ecran );

 /* Avons-nous ouvert l'écran avec succès ? */
 if(mon_ecran == NULL)
  nettoie();

 ma_nouvelle_fenetre.Screen = mon_ecran;

 /* Nous allons maintenant essayer d'ouvrir la fenêtre : */
 ma_fenetre = (struct Window *) OpenWindow( &ma_nouvelle_fenetre );
 
 /* Avons-nous ouvert la fenêtre avec succès ? */
 if(ma_fenetre == NULL)
  nettoie(); /* N'a pas pu ouvrir la fenêtre ! */


 /* 6. Initialise la structure GelsInfo : */

 /* Tous les sprites exceptés les deux premiers peuvent */
 /* servir à afficher les VSprites : ( 11111100 = 0xFC ). */
 ginfo.sprRsrvd = 0xFC;
 /* Si nous n'excluions pas les deux premiers sprites, les    */
 /* couleurs du pointeur de la souris pourraient être affectées. */


 /* Alloue de la mémoire à la structure GelsInfo : */
 ginfo.nextLine = prochaine_ligne;
 ginfo.lastColor = dernieres_couleurs;


 /* Donne au RastPort un pointeur sur la structure GelsInfo : */
 ma_fenetre->RPort->GelsInfo = &ginfo;


 /* Transmet la structure GelsInfo au système : */
 InitGels( &tete, &queue, &ginfo );


 /* 7. Initialise la structure VSprite : */

 vsprite.Flags = VSPRITE;   /* C'est un VSprite. */
 vsprite.X = x;             /* Position en X. */
 vsprite.Y = y;             /* Position en Y. */
 vsprite.Height = 16;       /* 16 lignes de haut. */
 vsprite.Width = 2;         /* Deux octets (16 pixels) de large. */
 vsprite.Depth = 2;         /* Deux bitplanes, 4 couleurs. */


 /* Pointeur sur les données du sprite : */
 vsprite.ImageData = donnees_vsprite;

 /* Pointeur sur la table de couleurs : */
 vsprite.SprColors = table_couleur;


 /* 8. Ajoute le VSprite à la liste des VSprites : */
 AddVSprite( &vsprite, ma_fenetre->RPort );

 /* Le VSprite est dans la liste. */
 vsprite_on = TRUE;


 /* Reste dans la boucle while jusqu'à ce que l'utilisateur */
 /* ait sélectionné le gadget de fermeture de la fenêtre :  */
 while( ferme_moi == FALSE )
 {
  /* Reste dans la boucle while aussi longtemps que nous */
  /* pouvons recevoir des messages avec succès :     */
  while(mon_message = (struct IntuiMessage *) GetMsg(ma_fenetre->UserPort))
  {
   /* Après que nous ayons reçu le message nous pouvons le lire et  sauver toute */
   /* valeur importante que nous pourrions vouloir vérifier plus tard : */
   class = mon_message->Class;
   code = mon_message->Code;

   /* Après que nous l'ayons lu nous répondons le plus vite possible : */
   /* RAPPEL ! N'essayez jamais de lire un message après que vous ayez */
   /* répondu ! Un autre processus pourrait l'avoir modifié. */
   ReplyMsg( mon_message );

   /* Teste quel indicateur IDCMP était envoyé : */
   switch( class )
   {
    case CLOSEWINDOW:   /* Quitte! */
        ferme_moi=TRUE;
        break; 

    case RAWKEY:     /* Une touche a été pressée ! */
        /* Teste quelle touche a été pressée : */
        switch( code )
        {
         /* Flèche vers le haut : */
         case 0x4C:   y_direction = -1; break; /* Pressée */
         case 0x4C+0x80: y_direction = 0; break; /* Relachée */

         /* Flèche vers le bas : */
         case 0x4D:   y_direction = 1; break; /* Pressée */
         case 0x4D+0x80: y_direction = 0; break; /* Relachée */

         /* Flèche vers la droite : */
         case 0x4E:   x_direction = 2; break; /* Pressée */
         case 0x4E+0x80: x_direction = 0; break; /* Relachée */

         /* Flèche vers la gauche : */
         case 0x4F:   x_direction = -2; break; /* Pressée */
         case 0x4F+0x80: x_direction = 0; break; /* Relachée */
        }
        break; 
   }
  }


  /* 12. Joue avec le VSprite : */

  /* Change les positions x/y : */
  x += x_direction;
  y += y_direction;

  /* Teste si le sprite ne sort pas de l'écran : */
  if(x > 320)
   x = 320;
  if(x < 0)
   x = 0;
  if(y > 200)
   y = 200;
  if(y < 0)
   y = 0;

  vsprite.X = x;
  vsprite.Y = y;


  /* 9. Classe la liste GEL : */
  SortGList( ma_fenetre->RPort );

  /* 10. Dessine la liste GEL : */
  DrawGList( ma_fenetre->RPort, &(mon_ecran->ViewPort) );

  /* 11. Met en marche le Copper et redessine l'affichage : */
  MakeScreen( mon_ecran );
  RethinkDisplay();
 }


 /* Libère toute la mémoire réservée : (ferme la fenêtre, */
 /* l'écran, les bibliothèques...)            */
 nettoie();

 /* FIN */
}


/* Cette fonction libère toute la mémoire réservée. */
void nettoie()
{
 /* 13. Supprime les VSprites : */
 if( vsprite_on )
  RemVSprite( &vsprite );

 if( ma_fenetre )
  CloseWindow( ma_fenetre );

 if(mon_ecran )
  CloseScreen( mon_ecran );

 if( GfxBase )
  CloseLibrary( GfxBase );

 if( IntuitionBase )
  CloseLibrary( IntuitionBase );

 exit();
}