Obligement - L'Amiga au maximum

Dimanche 26 septembre 2021 - 13:56  

Translate

En De Nl Nl
Es Pt It Nl


Rubriques

 · Actualité (récente)
 · Actualité (archive)
 · Comparatifs
 · Dossiers
 · Entrevues
 · Matériel (tests)
 · Matériel (bidouilles)
 · Points de vue
 · En pratique
 · Programmation
 · Reportages
 · Quizz
 · Tests de jeux
 · Tests de logiciels
 · Tests de compilations
 · Trucs et astuces
 · Articles divers

 · Articles in english


Twitter

Suivez-nous sur Twitter




Liste des jeux Amiga

0, A, B, C, D, E, F,
G, H, I, J, K, L, M,
N, O, P, Q, R, S, T,
U, V, W, X, Y, Z,
ALL


Trucs et astuces

0, A, B, C, D, E, F,
G, H, I, J, K, L, M,
N, O, P, Q, R, S, T,
U, V, W, X, Y, Z


Glossaire

0, A, B, C, D, E, F,
G, H, I, J, K, L, M,
N, O, P, Q, R, S, T,
U, V, W, X, Y, Z


Galeries

 · Menu des galeries

 · BD d'Amiga Spécial
 · Caricatures Dudai
 · Caricatures Jet d'ail
 · Diagrammes de Jay Miner
 · Images insolites
 · Fin de jeux (de A à E)
 · Fin de Jeux (de F à O)
 · Fin de jeux (de P à Z)
 · Galerie de Mike Dafunk
 · Logos d'Obligement
 · Pubs pour matériels
 · Systèmes d'exploitation
 · Trombinoscope Alchimie 7
 · Vidéos


Téléchargement

 · Documents
 · Jeux
 · Logiciels
 · Magazines
 · Divers


Liens

 · Sites de téléchargements
 · Associations
 · Pages Personnelles
 · Matériel
 · Réparateurs
 · Revendeurs
 · Presse et médias
 · Programmation
 · Logiciels
 · Jeux
 · Scène démo
 · Divers


Partenaires

Annuaire Amiga

Amedia Computer

Relec


A Propos

A propos d'Obligement

A Propos


Contact

David Brunet

Courriel

 


Programmation : Amiga C Manual - Sprites
(Article écrit par Anders Bjerin et extrait d'Amiga C Manual - mars 1990)


Note : traduction par Serge Hammouche.

10. Sprites

10.1 Introduction

Les sprites sont de petits objets qui peuvent être déplacés sur l'écran sans altérer le fond de l'image. L'Amiga possède huit canaux DMA, ce qui nous permet de bénéficier de huit sprites matériels. L'intérêt d'utiliser les sprites matériels réside dans le fait qu'ils peuvent être déplacés, animés, etc. sans interférer avec le processeur principal. Ils peuvent de ce fait être déplacés extrêmement rapidement et sont également très faciles à gérer.

Les sprites peuvent être utilisés dans de nombreuses situations. Si vous écrivez un jeu, vous pouvez utiliser les sprites comme ennemis, missiles, explosion, etc. Même en ce moment, alors que vous lisez ceci, un sprite est utilisé. Le pointeur Intuition (la souris) est en effet un sprite comme indiqué dans le chapitre 2 - Les fenêtres.

10.2 Limitations

Les sprites sont de merveilleuses petites choses mais ils possèdent quelques limitations :
  1. Les sprites peuvent seulement avoir 16 pixels de largeur (il n'y a aucune limite en ce qui concerne leur hauteur). Les sprites utilisent toujours des pixels de basse résolution. Même si vous avez un écran en haute résolution, les sprites seront en basse résolution. Ceci montre combien les sprites sont indépendants.
  2. Chaque sprite ne peut utiliser que trois couleurs plus une couleur "transparente".
  3. Il n'existe que huit sprites matériels.
Ces limitations peuvent être dépassées :
  1. Vous pouvez placer deux sprites ou plus côte à côte afin de créer un objet de largeur supérieure à 16 pixels.
  2. Vous pouvez "rattacher" deux sprites et porter ainsi le nombre de couleurs disponibles de 3 à 15 plus une transparente.
  3. Il est possible de réutiliser chaque sprite matériel pour "asperger" l'écran avec plusieurs sprites (VSprites).
10.3 Couleurs

Chaque sprite peut avoir trois couleurs différentes plus une couleur transparente. Les sprites 0 et 1 utilisent les registres de couleur 16 à 19, les sprites 2 et 3 utilisent les registres de couleur 20 à 23 et ainsi de suite :

Sprite   Registres de couleur
--------------------------------------
0 et 1   16 - 19  (16 est transparente)
2 et 3   20 - 23  (20 est transparente)
4 et 5   24 - 27  (24 est transparente)
6 et 7   28 - 31  (28 est transparente)

Deux choses importantes à rappeler :

Les sprites 0 et 1, 2 et 3, 4 et 5, 6 et 7, utilisent les mêmes registres de couleur. Si vous modifiez le registre de couleur 17, à la fois le sprite 0 et le sprite 1 seront affectés.

Si vous avez un écran basse résolution de profondeur 5 (32 couleurs), les 16 dernières couleurs seront partagées par les sprites et l'écran. Cependant, si vous utilisez seulement un écran à 16 couleurs (profondeur 4), vous utilisez malgré tout les 16 registres de couleur supérieurs pour les sprites. Cela signifie que vous pouvez avoir un écran à 16 couleurs et utiliser 16 autres couleurs pour les sprites.

Les registres de couleur 16, 20, 24 et 28 sont "transparents", ce qui signifie que la couleur de fond sera visible à travers. Ces registres peuvent contenir n'importe quel type de couleur puisqu'ils n'affectent pas les sprites.

10.4 Accéder aux sprites matériels

Si vous désirez utiliser un sprite matériel, vous devez :
  1. Déclarer et initialiser quelques données graphiques sur le sprite.
  2. Déclarer et initialiser une structure SimpleSprite.
  3. Appeler la fonction GetSprite() avec, pour paramètre, un pointeur sur votre structure SimpleSprite et une demande pour le sprite que vous voulez.
  4. Déplacer le sprite en appelant la fonction MoveSprite() et l'animer en changeant les données graphiques du sprite (ChangeSprite()).
  5. Restituer le sprite à la machine quand vous n'en avez plus besoin en appelant la fonction FreeSprite().
10.4.1 Données du sprite

Nous avons déjà décrit comment créer vos propres données de sprite au cours du chapitre 2 - Les fenêtres mais voici tout de même un court résumé :

Première étape

La première chose que vous avez à faire est de dessiner sur un papier à quoi le sprite devrait ressembler. Souvenez-vous que le sprite peut avoir seulement 16 pixels de largeur, mais n'importe quelle hauteur (Vous pouvez bien sûr placer deux sprites côte à côte si vous avez besoin d'un sprite plus large que 16 pixels). Souvenez-vous aussi que vous ne pouvez utiliser que trois couleurs par sprite).

Imaginez que vous ayez abouti à la proposition suivante :

    0000000110000000    0 : Transparente
    0000001111000000    1 : Rouge
    0000011111100000    2 : Jaune
    0000111111110000    3 : Vert
    0001111111111000
    0011111111111100
    0111111111111110
    2222222222222222
    2222222222222222
    0333333333333330
    0033333333333300
    0003333333333000
    0000333333330000
    0000033333300000
    0000003333000000
    0000000330000000

Deuxième étape

Vous devez maintenant traduire ceci en données de sprite. Chaque ligne du graphique va être traduite en deux mots de données. Le premier mot représente le premier plan de bits, et le second mot le second plan de bits. L'idée est la suivante : si vous voulez la couleur 0, les plans de bit 0 et 1 devront valoir 0, si vous voulez la couleur 1, le plan de bits 0 vaudra 1 et le plan de bits 1, 0 et ainsi de suite :

Couleur   Plan de bits 1   Plan de bits 0    Puisque
-------------------------------------------------------------------
   0          0                0             00 Binaire = Couleur 0
   1          0                1             01 Binaire = Couleur 1
   2          1                0             10 Binaire = Couleur 2
   3          1                1             11 Binaire = Couleur 3

Les données pour le pointeur ressembleraient à ceci :

Plan de bits 0     Plan de bits 1

0000000110000000   0000000000000000
0000001111000000   0000000000000000
0000011111100000   0000000000000000
0000111111110000   0000000000000000
0001111111111000   0000000000000000
0011111111111100   0000000000000000
0111111111111110   0000000000000000
0000000000000000   1111111111111111
0000000000000000   1111111111111111
0111111111111110   0111111111111110
0011111111111100   0011111111111100
0001111111111000   0001111111111000
0000111111110000   0000111111110000
0000011111100000   0000011111100000
0000001111000000   0000001111000000
0000000110000000   0000000110000000

Troisième étape

Le dernier travail consiste à transformer les chiffres binaires en type UWORD. Groupez les chiffres binaires par quatre et transformez-les en hexadécimal :

0000 =  0          0100 =  4          1000 =  8          1100 =  C
0001 =  1          0101 =  5          1001 =  9          1101 =  D
0010 =  2          0110 =  6          1010 =  A          1110 =  E
0011 =  3          0111 =  7          1011 =  B          1111 =  F

Le résultat ressemblera à ceci :

  0       1
-------------
0180    0000      0000 0001 1000 0000  0000 0000 0000 0000
03C0    0000      0000 0011 1100 0000  0000 0000 0000 0000
07E0    0000      0000 0111 1110 0000  0000 0000 0000 0000
0FF0    0000      0000 1111 1111 0000  0000 0000 0000 0000
1FF8    0000      0001 1111 1111 1000  0000 0000 0000 0000
3FFC    0000      0011 1111 1111 1100  0000 0000 0000 0000
7FFE    0000      0111 1111 1111 1110  0000 0000 0000 0000
0000    FFFF      0000 0000 0000 0000  1111 1111 1111 1111
0000    FFFF      0000 0000 0000 0000  1111 1111 1111 1111
7FFE    7FFE      0111 1111 1111 1110  0111 1111 1111 1110
3FFC    3FFC      0011 1111 1111 1100  0011 1111 1111 1100
1FF8    1FF8      0001 1111 1111 1000  0001 1111 1111 1000
0FF0    0FF0      0000 1111 1111 0000  0000 1111 1111 0000
07E0    07E0      0000 0111 1110 0000  0000 0111 1110 0000
03C0    03C0      0000 0011 1100 0000  0000 0011 1100 0000
0180    0180      0000 0001 1000 0000  0000 0001 1000 0000

Quatrième étape

Puisque l'Amiga a besoin de sauvegarder la position du sprite, sa taille, etc., vous devez aussi déclarer deux mots vides au début, et deux mots vides à la fin des données du sprite. Ces mots seront initialisés et maintenus par Intuition, donc vous n'avez pas à vous préoccuper d'eux.

Une déclaration et initialisation de données du sprite pourrait donc être :

    UWORD chip my_sprite_data[36]=
    {
      0x0000, 0x0000,

      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,
      
      0x0000, 0x0000
    };

Important : souvenez vous que toutes les données d'image doivent (toujours !) être chargées dans la mémoire Chip (les 512 ko de mémoire inférieurs). Si vous utilisez le Lattice C V5.00 ou supérieur, vous pouvez utiliser le mot clé "chip" devant le nom de votre nom d'image. Vérifiez le manuel de votre compilateur.

10.4.2 La structure SimpleSprite

La structure SimpleSprite ressemble à ceci :

struct SimpleSprite
{
  UWORD *posctldata;
  UWORD hauteur;
  UWORD x, y;
  UWORD num;
};
  • posctldata : pointeur sur un tableau de UWORDs qui est utilisé pour les données graphiques du sprite.
  • hauteur : hauteur du sprite (nombre de lignes). Les sprites matériels ont toujours 16 pixels de large.
  • x, y : position à l'écran relative au ViewPort/View (affichage).
  • num : numéro du sprite (0-7). Lorsque vous appelez la fonction GetSprite(), elle initialise automatiquement ce champ avec la numéro du sprite réservé, aussi mettez le à -1 pour le moment.
10.4.3 Réserver un sprite

Avant que vous n'utilisiez un sprite matériel, vous devez l'avoir réservé. Puisque l'Amiga est multitâche, il peut arriver qu'un autre programme utilise le sprite. Vous réservez un sprite en appelant la fonction GetSprite() :
  • Synopsis : sprite_obtenu = GetSprite( mon_sprite, sprite_désiré );
  • sprite_obtenu : (long). GetSprite() renvoie le numéro du sprite que vous avez obtenu (0-7). Si elle n'a pas pu obtenir le sprite désiré, elle retourne la valeur -1. Pensez à vérifier si vous avez obtenu le sprite que vous souhaitiez ! (le champ "num" de la structure SimpleSprite sera aussi initialisé automatiquement).
  • mon_sprite : (struct SimpleSprite *). Pointeur sur votre structure SimpleSprite.
  • sprite_désiré : (long) le numéro du sprite matériel que vous souhaitez utiliser (0-7). Si vous n'avez pas besoin d'un numéro particulier, vous pouvez écrire -1. Le système vous allouera alors n'importe quel sprite matériel disponible.
10.4.4 Jouer avec le sprite

Une fois que vous avez réservé un sprite, vous pouvez commencer à jouer avec lui. Vous déplacez le sprite en appelant la fonction MoveSprite() :
  • Synopsis : MoveSprite( view_port, mon_sprite, x, y );
  • view_port : (struct ViewPort *). Pointeur sur le ViewPort auquel le sprite est relié, ou 0 si le sprite doit être relié à la vue (View) courante.
  • mon_sprite : (struct SimpleSprite *). Pointeur sur votre structure SimpleSprite.
  • x, y : (long). La nouvelle position à l'écran (attention, les sprites utilisent des pixels de basse résolution).
Par exemple, MoveSprite ( 0, &mon_sprite, 30, 50 ); déplace le sprite (mon_sprite) jusqu'à la position (30, 50) (relativement à la vue courante).

Vous pouvez aussi modifier l'image (données du sprite) d'un sprite afin de l'animer. Il suffit d'appeler la fonction ChangeSprite() avec pour paramètre un pointeur vers de nouvelles données graphiques, et le reste est fait à votre place.
  • Synopsis : ChangeSprite( view_port, mon_sprite, nouvelle_image );
  • view_port : (struct ViewPort *). Pointeur sur le ViewPort auquel est relié le sprite, ou 0 si le sprite est relié à la vue (View) courante.
  • mon_sprite : (struct SimpleSprite *). Pointeur sur votre structure SimpleSprite.
  • nouvelle_image : (short *). Pointeur sur les nouvelles données du sprite.
10.4.5 Libérer le sprite

Quand vous n'avez plus besoin du sprite (quand votre programme se termine par exemple), vous devez libérer le sprite pour qu'une autre tâche puisse l'utiliser si nécessaire. Important : vous devez libérer tous les sprites que vous avez alloués, sinon aucune autre tâche ne pourra s'en servir et le seul moyen de libérer le matériel est alors de réinitialiser la machine. Vous libérez un sprite en appelant la fonction FreeSprite() :
  • Synopsis : FreeSprite( sprite_utilisé );
  • sprite_utilisé : (long). Numéro du sprite que vous voulez libérer (0-7).
10.4.6 Structure d'un programme

Un programme utilisant des sprites ressemblerait à ceci :

/* Puisque nous utilisons les sprites nous avons besoin de ce fichier : */
#include 

/* 1. Déclare et initialise quelques données graphiques du sprite : */
UWORD chip données_mon_sprite[36]=
{
 0x0000, 0x0000,

 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,

 0x0000, 0x0000
};

/* 2. Déclare et initialise une structure SimpleSprite : */
struct SimpleSprite mon_sprite=
{
  données_mon_sprite, /* posctldata, pointeur sur les données du sprite. */
  16,                 /* hauteur, 16 lignes. */
  40, 20,             /* x, y, position à l'écran. */
  -1,                 /* num, ce champ est automatiquement */
                      /* initialisé quand on appelle la    */
                      /* fonction GetSprite(), aussi nous  */
                      /* mettons -1 pour le moment.        */
};

UWORD chip mouvelle_image_sprite[26]=
{
  0x0000, 0x0000,
  and so on...

main()
{
  /* Ouvrir la bibliothèque Graphic.library, etc. */

  /* 3. Appelle la fonction GetSprite() avec pour paramètres */
  /*    un pointeur sur votre structure SimpleSprite et      */
  /*    une demande pour le sprite que vous souhaitez.       */
  /*    Essaie de réserver le sprite numéro 2 :              */
  if( GetSprite( &mon_sprite, 2 ) != 2 )
  {
    /* ERREUR ! */
    /* N'a pas pu réserver le sprite numéro 2. */
  }

  /* 4. Déplacer le sprite en appelant la fonction */
  /*    MoveSprite() et l'anime en modifiant les   */
  /*    données graphiques du sprite à l'aide de   */
  /*    fonction ChangeSprite().                   */

  /* Déplace le sprite jusqu'à la position (20,30) */
  MoveSprite( 0, &mon_sprite, 20, 30 );
  
  /* Modifie les données graphiques du sprite : */
  ChangeSprite( 0, &mon_sprite, nouvelle_image_sprite );

  /* 5. Rend le sprite au matériel quand vous n'en avez plus */
  /*    besoin en appelant la fonction FreeSprite() :        */
  FreeSprite( mon_sprite.num );

  /* Ferme d'autres choses (bibliothèques, etc) */
}

10.5 Techniques

Puisque les déplacements et modifications du sprite sont effectués par le matériel, ceci se fait à la vitesse de la lumière sans que le processeur principal n'en ait connaissance. Si vous le pouvez, vous devriez utiliser les sprites puisque le matériel est spécialisé dans leur gestion. Cependant il y a, comme mentionné plus tôt, quelques limitations qui peuvent poser des problèmes ; mais en utilisant quelques techniques spéciales, vous pouvez arriver quasiment à tout. Les sprites peuvent également servir pour créer quelques effets spéciaux intéressants, et sont parfaits pour l'animation.

10.5.1 Sprites plus larges

Si vous voulez un vaisseau spatial de 32 pixels de large, vous pouvez utiliser deux sprites côte à côte afin d'obtenir l'effet souhaité. Chaque fois que vous déplacez le vaisseau, vous appelez deux fois la fonction MoveSprite(). Puisque les sprites se déplacent très vite, l'utilisateur ne réalisera jamais que le vaisseau est constitué de deux sprites.

(30,50)        (30+16, 50)
    *--------------*----------------
    |          ####|####           |
    |         #   #|#  ##          |
    | #############|############## |
    |##############|###############|
    | #############|############## |
    --------------------------------
        Sprite 2       Sprite 3

Si vous utilisez tous les huit sprites, vous pouvez obtenir une image de 128 pixels de large et de n'importe quelle hauteur. Je ne pense pas que vous ayez besoin d'un vaisseau de plus grande taille.

10.5.2 Plus de couleurs

Chaque sprite peut utiliser seulement trois couleurs plus une transparente. Cependant, il est possible d'attacher deux sprites et donc d'utiliser 15 couleurs plus une transparente (puisque chaque sprite utilise deux plans de bits, ceci signifie qu'un sprite attaché possède quatre plans de bits, ce qui donne 16 combinaisons = 15 couleurs + une transparente).

Les sprites peuvent être attachés comme suit :
  • 1 à 0 : positionnez le bit SPRITE_ATTACHED dans les données du sprite 1.
  • 3 à 2 : positionnez le bit SPRITE_ATTACHED dans les données du sprite 3.
  • 5 à 4 : positionnez le bit SPRITE_ATTACHED dans les données du sprite 5.
  • 7 à 6 : positionnez le bit SPRITE_ATTACHED dans les données du sprite 7.
Les sprites pairs (0, 2, 4 et 6) sont appelés sprites inférieurs alors que les sprites impairs (1, 3, 5 et 7) sont appelés sprites supérieurs.

Quand vous voulez utiliser un sprite attaché, vous devez :
  1. Déclarer et initialiser deux tableaux de données de sprites.
  2. Positionner le bit Attach (pour le sprite impair 1, 3, 5, 7) dans le second mot des données du sprite.
  3. Une fois que vous avez réservé les deux sprites par GetSprite(), ils peuvent être déplacés. Il est important que les deux sprites soient déplacés ensemble pour que le mode Attach fonctionne, sinon ils redeviendront des sprites à trois couleurs.
10.5.2.1 Données de sprites à 15 couleurs

Comme vous l'avez vu auparavant, les données de sprite sont constituées de deux plans de bits. Quand vous attachez deux sprites, nous pouvons par conséquent obtenir quatre plans de bits et donc 15 couleurs plus une transparente.

Le sprite inférieur fournit les plans de bits 0 et 1, pendant que le sprite supérieur fournit les plans de bits 2 et 3.

Aussi, si vous voulez que le sprite ressemble à ceci :

0000000000000000   0 : registre de couleur 16 (transparent)
1111111111111111   1 : registre de couleur 17 (transparent)
2222222222222222   2 : registre de couleur 18 (transparent)
3333333333333333   3 : registre de couleur 19 (transparent)
4444444444444444   4 : registre de couleur 20 (transparent)
5555555555555555   5 : registre de couleur 21 (transparent)
6666666666666666   6 : registre de couleur 22 (transparent)
7777777777777777   7 : registre de couleur 23 (transparent)
8888888888888888   8 : registre de couleur 24 (transparent)
9999999999999999   9 : registre de couleur 25 (transparent)
AAAAAAAAAAAAAAAA   A : registre de couleur 26 (transparent)
BBBBBBBBBBBBBBBB   B : registre de couleur 27 (transparent)
CCCCCCCCCCCCCCCC   C : registre de couleur 28 (transparent)
DDDDDDDDDDDDDDDD   D : registre de couleur 29 (transparent)
EEEEEEEEEEEEEEEE   E : registre de couleur 30 (transparent)
FFFFFFFFFFFFFFFF   F : registre de couleur 31 (transparent)

...les quatre plans de bits ressembleraient à ceci :

Plan de bits 3   Plan de bits 2   Plan de bits 1   Plan de bits 0
-------------------------------------------------------------------
0000000000000000 0000000000000000 0000000000000000 0000000000000000
0000000000000000 0000000000000000 0000000000000000 1111111111111111
0000000000000000 0000000000000000 1111111111111111 0000000000000000
0000000000000000 0000000000000000 1111111111111111 1111111111111111
0000000000000000 1111111111111111 0000000000000000 0000000000000000
0000000000000000 1111111111111111 0000000000000000 1111111111111111
0000000000000000 1111111111111111 1111111111111111 0000000000000000
0000000000000000 1111111111111111 1111111111111111 1111111111111111
1111111111111111 0000000000000000 0000000000000000 0000000000000000
1111111111111111 0000000000000000 0000000000000000 1111111111111111
1111111111111111 0000000000000000 1111111111111111 0000000000000000
1111111111111111 0000000000000000 1111111111111111 1111111111111111
1111111111111111 1111111111111111 0000000000000000 0000000000000000
1111111111111111 1111111111111111 0000000000000000 1111111111111111
1111111111111111 1111111111111111 1111111111111111 0000000000000000
1111111111111111 1111111111111111 1111111111111111 1111111111111111

Transformé en hexadécimal, on obtiendrait :

   3    2    1    0
-------------------
0000 0000 0000 0000
0000 0000 0000 FFFF
0000 0000 FFFF 0000
0000 0000 FFFF FFFF
0000 FFFF 0000 0000
0000 FFFF 0000 FFFF
0000 FFFF FFFF 0000
0000 FFFF FFFF FFFF
FFFF 0000 0000 0000
FFFF 0000 0000 FFFF
FFFF 0000 FFFF 0000
FFFF 0000 FFFF FFFF
FFFF FFFF 0000 0000
FFFF FFFF 0000 FFFF
FFFF FFFF FFFF 0000
FFFF FFFF FFFF FFFF

Maintenant, nous n'avons plus qu'à écrire ça dans deux tableaux de données de sprites. Souvenez-vous que le sprite inférieur (0, 2, 4 ou 6) fournit les plans de bits 0 et 1, alors que le sprite supérieur (1, 3, 5 ou 7) fournit les plans de bits 2 et 3 :

/* Données pour le sprite inférieur : */
UWORD chip données_sprite_inférieur[36]=
{
  0x0000, 0x0000,

  /* Plan de bits */
  /* 0       1    */
  
  0x0000, 0x0000,
  0xFFFF, 0x0000,
  0x0000, 0xFFFF,
  0xFFFF, 0xFFFF,

  0x0000, 0x0000,
  0xFFFF, 0x0000,
  0x0000, 0xFFFF,
  0xFFFF, 0xFFFF,

  0x0000, 0x0000,
  0xFFFF, 0x0000,
  0x0000, 0xFFFF,
  0xFFFF, 0xFFFF,

  0x0000, 0x0000,
  0xFFFF, 0x0000,
  0x0000, 0xFFFF,
  0xFFFF, 0xFFFF,
    
  0x0000, 0x0000
};

/* Données pour le sprite supérieur : */
UWORD chip données_sprite_supérieur[36]=
{
  0x0000, 0x0000,

 /*  Plan de bits  */
 /*  2       3     */
  0x0000, 0x0000,
  0x0000, 0x0000,
  0x0000, 0x0000,
  0x0000, 0x0000,

  0xFFFF, 0x0000,
  0xFFFF, 0x0000,
  0xFFFF, 0x0000,
  0xFFFF, 0x0000,

  0x0000, 0xFFFF,
  0x0000, 0xFFFF,
  0x0000, 0xFFFF,
  0x0000, 0xFFFF,

  0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF,
    
  0x0000, 0x0000
};

10.5.2.2 Attacher des sprites

Pour relier deux sprites, vous devez simplement positionner l'indicateur SPRITE_ATTACHED dans le second mot des données du sprite supérieur. Ainsi, si vous voulez relier le sprite 3 avec le sprite 2, vous devez positionner l'indicateur SPRITE_ATTACHED dans les données du sprite 3.

données_sprite_supérieur[ 1 ] = SPRITE_ATTACHED;

ou :

UWORD chip données_sprite_supérieur[36]=
{
  0x0000, SPRITE_ATTACHED,

Et ainsi de suite...

10.5.2.3 Déplacer des sprites attachés

Une fois que deux sprites sont attachés, vous n'avez qu'à les réserver, et vous aurez un sprite à 15 couleurs :

 /* Réserve le sprite 2 comme sprite inférieur : */
  sprite_inférieur_obtenu = GetSprite( &mon_sprite_inférieur, 2 );

  if( sprite_inférieur_obtenu != 2 )
    /* ERREUR ! */

  /* Réserve le sprite 3 comme sprite supérieur : */
  sprite_supérieur_obtenu = GetSprite( &mon_sprite_supérieur, 3 );

  if( sprite_supérieur_obtenu != 3 )
    /* ERREUR ! */

Il est important que les deux sprites soient déplacés simultanément pour que la fonction Attach fonctionne. La bonne nouvelle est que si vous déplacez le sprite inférieur, le sprite supérieur sera aussi déplacé automatiquement. Si par contre vous déplacez seulement le sprite supérieur, le sprite inférieur demeurera inchangé, et la fonction spéciale Attach ne fonctionnera pas (retour à 3 couleurs).

Si vous voulez vous amuser vous pouvez réserver le sprite 1 et positionner l'indicateur SPRITE_ATTACHED. Puisque le sprite 0 est déjà utilisé comme pointeur par Intuition, le sprite 1 sera attaché au pointeur, et vous pourrez avoir un pointeur en 15 couleurs ! A chaque fois qu'Intuition déplace le pointeur (le sprite 0, qui est le sprite inférieur), votre sprite (le sprite 1, sprite supérieur) sera déplacé automatiquement. Vous pouvez modifier le pointeur Intuition en appelant la fonction SetPointer. Référez-vous au chapitre 2 - Les fenêtres pour de plus amples informations.

10.5.3 Niveaux

Chaque sprite possède son propre "niveau" (priorité) ce qui signifie que certains sprites se déplaceront au-dessus et d'autres au-dessous des autres sprites quand ils se toucheront. Le plus grand numéro de sprite possède le niveau le plus bas (priorité). Cela signifie que le sprite 3 se déplacera au dessus du sprite 4, alors que le sprite 2 passera au dessus du sprite 3 :

 --------
 | 7    |
 |   --------
 ----| 6    |
     |   --------
     ----| 5    |
         |   --------
         ----| 4    |
             |   --------
             ----| 3    |
                 |   --------
                 ----| 2    |
                     |   --------
                     ----| 1    |
                         |   --------
                         ----| 0    |
                             |      |
                             --------

Ceci peut être utilisé de nombreuses façons. Par exemple, si vous écrivez un jeu avec un petit bonhomme sautant dans une boîte, vous pouvez utiliser deux sprites : un pour le bonhomme, un deuxième pour la boîte. La chose importante à rappeler est que cette boîte doit avoir un numéro de sprite inférieur à celui du bonhomme. Si vous placez le bonhomme à la même position que la boîte, il semblera entrer dans la boîte :

     O
   -----
     |
     ^         #######
    / \        #######
   Bonhomme     Boîte  
  (sprite 2)  (sprite 1)

     O
   -----
     |
  #######
  #######
  Bonhomme (sprite 2)
  Boîte    (sprite 1)

10.6 Fonctions

GetSprite()

Cette fonction réserve un sprite. Vous devez toujours réserver un sprite avant que vous ne puissiez l'utiliser.
  • Synopsis : sprite_obtenu = GetSprite( mon_sprite, sprite_désiré );
  • sprite_obtenu : (long). GetSprite() renvoie le numéro du sprite que vous avez obtenu (0-7). Si elle n'a pas pu obtenir le sprite désiré, elle retourne la valeur -1. Pensez à vérifier si vous avez obtenu le sprite que vous souhaitiez ! (le champ "num" de la structure SimpleSprite sera aussi initialisé automatiquement).
  • mon_sprite : (struct SimpleSprite *). Pointeur sur votre structure SimpleSprite.
  • sprite_désiré : (long). Le numéro du sprite matériel que vous souhaitez utiliser (0-7). Si vous n'avez pas besoin d'un numéro particulier, vous pouvez écrire -1. Le système vous allouera alors n'importe quel sprite matériel disponible.
MoveSprite()

Utilisez cette fonction pour déplacer un sprite.
  • Synopsis : MoveSprite( view_port, mon_sprite, x, y );
  • view_port : (struct ViewPort *). Pointeur sur le ViewPort auquel le sprite est relié, ou 0 si le sprite doit être relié à la vue (View) courante.
  • mon_sprite : (struct SimpleSprite *). Pointeur sur votre structure SimpleSprite.
  • x, y : (long). La nouvelle position à l'écran (attention les sprites utilisent des pixels de basse résolution).
ChangeSprite()

Cette fonction modifie les données (l'image) d'un sprite.
  • Synopsis : ChangeSprite( view_port, mon_sprite, nouvelle_image );
  • view_port : (struct ViewPort *). Pointeur sur le ViewPort auquel est relié le sprite, ou 0 si le sprite est relié à la vue (View) courante.
  • mon_sprite : (struct SimpleSprite *). Pointeur sur votre structure SimpleSprite.
  • nouvelle_image : (short *). Pointeur sur les nouvelles données du sprite.
FreeSprite()

Cette fonction rend au matériel un sprite réservé auparavant.
  • Synopsis : FreeSprite( sprite_utilisé );
  • sprite_utilisé : (long). Numéro du sprite que vous voulez libérer (0-7).
WaitTOF()

Cette fonction attend que le balayage vidéo ait atteint le sommet de l'écran. Elle peut être utilisé si vous voulez diminuer un peu la vitesse, et rend l'animation plus souple.
  • Synopsis : WaitTOF();
10.7 Exemples

Voici des exemples (dans le répertoire "Amiga_C_Manual/10.Sprites") montrant des sprites :

Exemple 1

Ce programme montre comment déclarer et initialiser des données de sprite et une structure SimpleSprite. Il montre aussi comment réserver un sprite (sprite 2) et comment le déplacer. L'utilisateur déplace le sprite en utilisant les flèches de déplacement.

Exemple 2

Ce programme montre comment déclarer et initialiser des données de sprite et une structure SimpleSprite. Il montre aussi comment réserver un sprite (sprite 2) et comment le déplacer. L'utilisateur déplace le sprite en utilisant les flèches de déplacement. Dans cet exemple, nous animons le sprite (six images, tirées du jeu d'arcade Miniblast).

Exemple 3

Ce programme montre comment créer un sprite en 15 couleurs, et comment le déplacer.


[Retour en haut] / [Retour aux articles] [Chapitre précédent : Divers] / [Chapitre suivant : AmigaDOS]