DOCUMENTATION GFXENGINE FRO SDL
-------------------------------

Variables globale :
-----------------

int keyRight;  // Cette variable prends la valeur 1 quand la touche droite est enfonce
int keyLeft;   // Cette variable prends la valeur 1 quand la touche gauche est enfonce
int keyUp;     // Cette variable prends la valeur 1 quand la touche haut est enfonce
int keyDown;   // Cette variable prends la valeur 1 quand la touche bas est enfonce
int keyQuit;   // Cette variable prends la valeur 1 quand la touche pour quitter est enfonce
keyAction1
keyAction2
keyAction3
keyAction4
keyActionPause

IMPORTANT : Les images N 1 et 3 gre la transparence (Pixel 255 de couleur 255,255,255)

void initGfxEngine() :
--------------------

Cette function doit tre obligatoirement appele pour initialiser le mode vido.

int loadBmp(char *path,char *filename,char *totalpath,char *pathdc,int noImage) :
---------------------------------------------------------
+ path : rpertoire d'accs  l'image   GP32            +
+ filename : nom du fichier image       GP32            +
+ totalPath : repertoire + nom fichier  PC              +
+ pathdc : repertoire + nom fichier     DC              +
+ noImage : numro de l'image (0  3)                   +
---------------------------------------------------------

Charge une image BMP en mmoire.
Les images 1 et 3 vont utiliser la transparence. On utilise la transparence gnralement
lorsque l'on va dcouper des morceau de cette image pour des sprites.
La couleur de transparence en SDL est (255,255,255).
Pour GP32 la couleur de transparence est celle d'index 0, pour garder la 
compatibilit cette couleur d'index 0 doit tre de composante (255,255,255).

path et filename : chemin pour GP32 (gp:\\xxx\\xxxx\\ et test.bmp)
totalPath : chemin pour SDL (d:\\images\\toto.bmp)
pathdc : chemin pour Dreamcast (/rd/blocks.bmp)


void flipScreen() :
-----------------

Affiche les modifications graphique fait  l'cran

void waitInMs(int ms) :
------------------------------
+ ms : temps en milliseconde +
------------------------------

Ne fait rien pendant ms millisecondes

int synchroStart() :
------------------

Initialise la synchro de boucle

int synchroEnd(int ms) :
-------------------------
+ ms : temps de synchro +
-------------------------

Finit la synchro de boucle et attend le temps restant pour atteindre ms milliseconde.

EXEMPLE :
        
        While (1)
        {
               synchroStart()
               
               .. Traitement de jeu ..
               .. Affichage ..
               
               synchroEnd(5);
        }
        
        La boucle mettra au minimum 5 millisecondes  s'executer. Cela permet de synchroniser
        la vitesse du jeu pour tout les PC. Sur un PC plus lent, elle ne bloquera pas le PC.
     


int checkController() :
---------------------

Cette fonction appele dans une boucle scrupte le clavier et met  jour automatiquement
les variables :

int keyRight;  // Cette variable prends la valeur 1 quand la touche droite est enfonce
int keyLeft;   // Cette variable prends la valeur 1 quand la touche gauche est enfonce
int keyUp;     // Cette variable prends la valeur 1 quand la touche haut est enfonce
int keyDown;   // Cette variable prends la valeur 1 quand la touche bas est enfonce
int keyQuit;   // Cette variable prends la valeur 1 quand la touche pour quitter est enfonce



void blitImageToScreen(int imageNo,int sx,int sy,int sw,int sh,int dx,int dy,int dw,int dh,int ttw,int tth) :
--------------------------------------------------------------------------------------------------
+ imageNo : N de l'image source                                                                 +
+ sx : position x dans l'image source                                                            +
+ sy : position y dans l'image source                                                            +
+ sw : largeur  partir de la position sx,sy                                                     +
+ sh : hauteur  partir de la position sx,sy                                                     +
+ dx : position x dans l'image de destination (l'cran)                                          +
+ dy : position y dans l'image de destination (l'cran)                                          +
+ dw : largeur  partir de dx,dy dans l'image de destination (l'cran)                           +
+ dh : hauteur  partir de dx,dy dans l'image de destination (l'cran)                           +
+ ttw : Largeur totale de l'image source                                                         +
+ tth : Hauteur totale de l'image source                                                         +                                                                                         +
--------------------------------------------------------------------------------------------------

Copie une partie de l'image imageNo dans l'cran. Cette partie d'image peut tre dforme
dans l'cran en modifiant la taille grace  dw et dh. La couleur de transparence, est uniquement
utilise par la version GP32. Pour la compatibilit entre toutes les version, il est judicieux
de placer ce paramtre  0.


MOTEUR DE SPRITE
----------------

void initSpriteEngine() :
-----------------------

Cette function doit tre obligatoirement appele pour initialiser le moteur de sprite.


void getImage(int n,int x,int y,int l,int h,int imageNo,int w,int he) :
----------------------------------------------------------------------------
+ n : Numro que vous attribuez au morceau d'image                         +
+ x : position x du morceau                                                +
+ y : position y du morceau                                                +
+ l : largeur du morceau                                                   +
+ h : hauteur du morceau                                                   +
+ imageNo : A partir de quelle image source on rcupre ce morceau         +
+ w : largeur de l'image source                                            +
+ he : hauteur de l'image source                                           +
----------------------------------------------------------------------------

Cette fonction permet de se crer une banque de morceau d'image  partir d'images
sources chargs grace  la fonction loadBmp.
Les paramtres w,he semblent redondant, mais il est important de spcifier au
systme la taille de l'image source. La couleur de transparence tc, pour compatibilit
doit tre mise  0.

void initSprite(int n,int x,int y,int i) :
-------------------------------------------
+ n : Numro que vous attribuez au sprite +
+ x : position x                          +
+ y : position y                          +
+ i : Numro du morceau d'image           +
-------------------------------------------

Initialise un sprite n n avec une image i, et une position de dpart x,y. Attention
d'tre sur que le sprite n est bien libre ! Il est plutot conseill d'utiliser la mthode
initFreeSprite;


int initFreeSprite(int x,int y,int i) :
-------------------------------------------
+ x : position x                          +
+ y : position y                          +
+ i : Numro du morceau d'image           +
-------------------------------------------

Initialise un sprite avec une image i, et une position de dpart x,y. Cette fonction
retourne le n du sprite initialis.

Exemple : int playerShip = initFreeSprite(10,10,1);

void releaseSprite(int n) :
-------------------------
+ n : Numro du sprite  + 
-------------------------

Libre le sprite n, pour qu'il puisse tre rutilis.


void releaseAllSprite() :
-----------------------

Libre tout les sprites.

void animateSprite(int s,int a)
-------------------------------
+ s : N du sprite            +
+ a : N de l'animation (09) +
-------------------------------

Dclenche l'animation n a du sprite n s.

void setSpriteAnimation(int s,int a,int speed,int f0,int f1,int f2,int
f3,int f4,int f5,int f6,int f7,int f8,int f9,int f10,int f11,int
f12,int f13,int f14,int f15,int f16,int f17,int f18,int f19) :
--------------------------------------------------------------
+ s : N du sprite                                           +
+ a : N de l'animation (09)                                +
+ speed : Vitesse de l'animation                             +
+ f0  f19 : N des morceaux d'images composants l'animation +
--------------------------------------------------------------

Cre une animation pour un sprite s. Si une valeur de f. prend -1
on boule en repartant de f0.

void stopAnimateSprite(int s) :
-----------------------------
+ s : N du sprite          +
-----------------------------

Arrte l'animation du sprite s. Attention, le sprite reste sur sa dernire image.


void moveSprite(int n,int x,int y) :
-----------------------------------
+ n : Numro du sprite            +
+ x : position x                  +
+ y : position y                  +
-----------------------------------

Change la position du sprite n.


void changeSpriteImage(int n,int i) :
-----------------------------------
+ n : Numro du sprite            +
+ i : morceau d'image             +
-----------------------------------

Change l'image du sprite n.


void showSprite(int n) :
-----------------------------------
+ n : Numro du sprite            +
-----------------------------------

Affiche le sprite n  l'cran


void showLRSprite(int n)
-----------------------------------
+ n : Numro du sprite            +
-----------------------------------

Affiche le sprite n  l'cran en flip horizontal

IMPORTANT : ne fonctionne pas en SDL !

void showAllSprite() :
--------------------

Affiche tout les sprites  l'cran


int isSpriteCollide(int sprite1,int sprite2) :
--------------------------------------------
+ sprite1 : N du sprite 1                 +
+ sprite2 : N du sprite 2                 +
--------------------------------------------

Renvoie 1 si les 2 sprites sont en collision.


TILE ENGINE
-----------

Le tile engine, permet de dfinir une aire graphique de jeu. Dans le SDK de base
il y  4 aires (map) possible, de 100*100 briques (tiles).
Une tile, est compos d'un morceau d'image (captur par getImage) et de 3 attributs
qui vous sont libres. Une map est compos de tiles.

On distingue 2 type de coordonnes :
             - les coordonnes de tiles : max 100*100
             - les coordonnes de monde (world) : max 1600*1600
             
Pour crer la map, on lui indique des coordonnes de tiles. Pour l'afficher 
l'cran, des coordonnes de monde. Cela permet la gestion de scrolling extrmement
facilement.

void initTileEngine() :
---------------------

Initialise le moteur de Tiles et de Map

void createTile(int n,int imageNo,int a1,int a2,int a3) :
-------------------------------------------------------
+ n : N de la tile                                   +
+ imageNo : Morceau d'image composant la tile         +
+ a1 : attribut1                                      +
+ a2 : attribut2                                      +
+ a3 : attribut3                                      +
-------------------------------------------------------

Cre une Tile n n avec le morceau d'image imageNo (cr grace 
getImage). On lui dfinit 3 attribut libres a1,a2,a3


void setTileInMap(int mapNo,int x,int y,int tileNo) :
---------------------------------------------------
+ mapNo : Numro de la map                        +
+ x : position x de la brique (tile) dans la map  +
+ y : position y de la brique (tile) dans la map  +
+ tileNo : brique (tile)  affecter               +
---------------------------------------------------

Avec cette mthode on va crer la map, compos de Tiles.

void setWorldView(int mapNo,int x,int y) :
---------------------------------------------------------------
+ mapNo : Numro de la map                                    +
+ x : position x en PIXELS (coordonnes de monde)             +
+ y : position y en PIXELS (coordonnes de monde)             +
---------------------------------------------------------------

Grace  cela on peut se positionner au pixel prt dans la map.

void mapDraw(int mapNo) :
----------------------------
+ mapNo : Numro de la map +
----------------------------

Dessine la map dans l'cran

