|
|
|
|
|
|
1er chapitre – 3eme Partie : Même chose mais avec des collisions sur les bords d'écran et un fond
Avant d'ajouter quoi que ce soit, on va créer une structure qui va nous stocker l'abscisse et l'ordonnée. Ceci va nous faciliter les passages de paramètres. On va appeler cette structure Position :
Maintenant, on va se servir de cette structure pour remplacer les variables position_x et position_y :
- A la place des déclarations et des initialisations :
- A la place des passages de paramètres dans les fonctions
puis comme passage :
Autre modification, on va d'abord modifier la façon de bouger notre image. En effet, l'utilisation des événements est bien mais n'est pas parfaite avec SDL sur DC (au moment ou j'écris). Dans tous les cas, je n'arrive pas a avoir de résultat satisfaisants. On va donc utiliser des fonctions de KOS pures et dures pour remplacer le contenu de la boucle infinie. On va créer une fonction dont le but sera de bouger la position de l'image en fonction des actions de l'utilisateur. On va donc l'appeler Move_Image. Son rôle va être de prendre une position, de tester les actions de l'utilisateur, de modifier puis renvoyer la position. On aura donc une structure position en entrée et en sortie :
Il est nécessaire de mapper un contrôleur avant de pouvoir le tester. Le test retourne alors une variable de type cont_cond_t qui indique quel bouton est pressé.
On va donc, par la suite, tester les 4 axes de la manette et faire évoluer notre position en fonction :
Il ne reste plus alors qu'à retourner IN_Position. L'intérieur de la boucle infinie devient alors :
Comme on est fainéant, on profite aussi de nos tests de la manette pour tester le bouton START. Lors de l'utilisation, on va rebooter la dreamcast. De cette manière, plus besoin de se baisser pour appuyer sur le bouton power entre chaque test.
Maintenant, on va essayer de faire un fond d'écran. Pour ça, on va copier de windows un pattern (Aquarium) et s'en servir pour tapisser l'arrière plan derrière notre image. On copie donc aquarium.bmp dans le romdisk. Le principe de l'arrière plan est de copier autant de fois que nécessaire le pattern pour qu'il recouvre tout l'écran. On créera donc une fonction qui s'occupe de ça. La première chose à faire est de déclarer une variable globale de type surface et de charger dedans l'image aquarium :
puis dans Init()
La fonction qui dessine le background doit être générique et va donc prendre un pattern et tapisser une surface avec ce pattern. Notre fonction recevra donc en entrée un pattern et une surface cible. Le prototype sera :
Je vais partir du principe qu'on ne connaît pas à l'avance la taille de l'image destination. Du coup, on va dessiner des lignes avec le pattern tant que l'écran ne sera pas rempli horizontalement et verticalement. Une première boucle va remplir chaque ligne et une seconde va répéter l'opération tant que tout l'écran n'est pas rempli. Pour connaître la hauteur et la largeur d'une surface, on utilise les propriétés h et w. On va utiliser des compteurs pour suivre la position à laquelle on est. L'algorithme est donc : tant que la largeur des patterns déjà écrit (soit la largeur d'un pattern multiplié par le nb de pattern) est inférieure à la largeur de l'écran, j'écris un pattern. De cette manière, on écrit une ligne complète. On englobe cette boucle d'une deuxième qui dit : tant que la hauteur de ce qui est déjà écrit (nb de ligne écrites multiplié par la hauteur d'un pattern) est inférieure ou égale à la hauteur de la surface à remplir, j'écris une nouvelle ligne. Pour écrire, on utilise la fonction Blit_surface qu'on a déjà vue. La position est définie en fonction de la position en nb de lignes (int_compt2) et en colonnes (int_compt) Donc pour dessiner une ligne :
On va remplacer le coloriage de l'écran en noir de notre programme (SDL_FillRect( MainScreen, 0, 0 ) ;) par l'appel à la fonction Creation_Background(Background_Pattern, MainScreen); pour remplir avec le pattern Background_Pattern la surface qui représente l'écran MainScreen. Pour tester les collisions, on va tester la position de l'image par rapport à la taille de l'écran. Il faut que la surface image soit inclue dans la surface écran. On va donc créer une fonction qui retourne une position et qui va prendre en paramètre les deux images et la position de l'image à tester. Si l'image est inclue, la fonction va retourner la position d'origine, sinon, la fonction va adapter la position pour qu'elle reste inclue.
Tout d'abord, on bloque à 0 les coordonnées de la position pour qu'elles ne puissent pas être négative. De cette manière, on bloque l'image en haut et à gauche. Pour bloquer l'image à droite et en bas, il faut calculer en fonction de la taille de l'image et de la taille du support. La position correspond à l'angle haut gauche de l'image. Donc, pour que l'image soit bloquée à droite, il faut que la position soit inférieure à la taille du support moins la largeur de l'image. C'est le même raisonnement pour le bas. Tout ceci donne la fonction :
Et voilà, notre petit programme est complet et donne :
Page suivante : 1er chapitre – 4eme Partie : Pareil avec des objets qui bougent tout seul |