Apprenez à Programmer En C ! Par Mathieu Nebra (Mateo21

Log InSign Up

• Log In
• Sign Up
• more
• • About
  • Press
  • Papers
  • Terms
  • Privacy
  • Copyright
  • We're Hiring!
  • Help Center
  • less

Outline

keyboard_arrow_downTitleAbstractUne Question De PropretéCode : C Return Resultat;Referencesdownload

Download Free PDF

Download Free PDFApprenez à programmer en C ! Par Mathieu Nebra (Mateo21kevin ulrichvisibility

…

description

409 pages

descriptionSee full PDFdownloadDownload PDF bookmarkSave to LibraryshareShareclose

Sign up for access to the world's latest research

Sign up for freearrow_forwardcheckGet notified about relevant paperscheckSave papers to use in your researchcheckJoin the discussion with peerscheckTrack your impact

Abstract

i feeling that, this document is vey good and important. But now i'am working with SDL2 so SDL1.x is useless for me.

... Read more

Related papers

Cours Programmation CNess You

Programmation Structurée en Langage C , 2006

École Centrale Marseille Programmation Structurée en Langage C Stéphane Derrode Mathématique et Informatique Révision 2.5, 2006.

downloadDownload free PDFView PDFchevron_rightEcole Hassania des Travaux Publics Casablanca ,le 16/12/2016 Département de Mathématiques ,Informatique et Géomatique Filière SIG Mlle Mariam CHERRABI Programmation C -Projet à rendremohammed mhassni

Thèmes : Jeu FANORONA  Le fanoron(a)-telo ou an-telo ou fanorom-bazaha : (3 pions par joueur)  Le fanoron(a)-dimy ou an-dimy : (12 pions par joueur)  Le fanoron(a)-tsivy ou an-tsivy : (22 pions par joueur)  Variante traitée : Fanorona-Tsivy Annexes : (Règles du Jeu)  Pièces jointes : 1. [Géoludie,Un monde de jeu :Livret des règles :Le FANORONA]  Pour mieux comprendre : 2. [Géoludie,Un monde de jeu :Livret des règles :Le FANORONA-dimy]  Liens Internet: *Article en ligne des règles du jeu : http://www.lecomptoirdesjeux.com/regle-fanorona-madagascar.htm *Vidéo en ligne des règles du jeu : http://videoregles.net/videoregle/fanorona Remarques : 1) Le mot Fanorona, en l'absence de toute autre précision (telo, dimy ou tsivy) fait référence au Fanoron(a)-tsivy. Ainsi, "venez jouer au Fanorona" signifie "venez jouer au Fanoron(a)-tsivy". 2)  Telo = 3 : D'où, le Fanoron-telo a 3 intersections (3 pions) sur un côté.  Dimy = 5 : D'où, le Fanoron-dimy a 5 intersections (5 pions) sur un côté.  Sivy = 9 : D'où, le Fanoron-tsivy a 9 intersections (9 pions) sur un grand côté.

downloadDownload free PDFView PDFchevron_rightPolycopié de cours Module : Programmation C 1El Bachir Tazi

 Se familiariser avec l'environnement de programmation C  Connaître l'aspect syntaxique et sémantique du langage C  Ecrire des programmes corrects partant des programmes simples à des programmes complexes.

downloadDownload free PDFView PDFchevron_rightProgrammation en langage CSameh MAALAOUIdownloadDownload free PDFView PDFchevron_rightSee full PDFdownloadDownload PDF

Loading Preview

Sorry, preview is currently unavailable. You can download the paper by clicking the button above.

References (135)

1. Déroulement d'une partie ........................................................................................................................................................................................
2. Dictionnaire de mots ............................................................................................................................................................................................... La solution (1 : le code du jeu) ................................................................................................................................................................................
3. Analyse de la fonction main ....................................................................................................................................................................................
4. Analyse de la fonction gagne ..................................................................................................................................................................................
5. Analyse de la fonction rechercheLettre ................................................................................................................................................................... La solution (2 : la gestion du dictionnaire) ............................................................................................................................................................... Préparation des nouveaux fichiers .......................................................................................................................................................................... La fonction piocherMot ............................................................................................................................................................................................ La fonction nombreAleatoire .................................................................................................................................................................................... Le fichier dico.h ....................................................................................................................................................................................................... Le fichier dico.c ....................................................................................................................................................................................................... Il va falloir modifier le main ! .................................................................................................................................................................................... Idées d'amélioration ................................................................................................................................................................................................ Télécharger le projet ............................................................................................................................................................................................... Améliorez le Pendu ! ............................................................................................................................................................................................... La saisie de texte sécurisée .......................................................................................................................................... Les limites de la fonction scanf ............................................................................................................................................................................... Entrer une chaîne de caractères avec des espaces ............................................................................................................................................... Entrer une chaîne de caractères trop longue .......................................................................................................................................................... Récupérer une chaîne de caractères ...................................................................................................................................................................... La fonction fgets ...................................................................................................................................................................................................... Créer sa propre fonction de saisie utilisant fgets .................................................................................................................................................... Convertir la chaîne en nombre ................................................................................................................................................................................ strtol : convertir une chaîne en long ........................................................................................................................................................................ strtod : convertir une chaîne en double ................................................................................................................................................................... En résumé ............................................................................................................................................................................................................... Partie 3 : Création de jeux 2D en SDL ............................................................................................ Installation de la SDL .................................................................................................................................................... Pourquoi avoir choisi la SDL ? ................................................................................................................................................................................ Choisir une bibliothèque : pas facile ! .....................................................................................................................................................................
6. La SDL est un bon choix ! ....................................................................................................................................................................................... Les possibilités offertes par la SDL ......................................................................................................................................................................... Téléchargement de la SDL ...................................................................................................................................................................................... Créer un projet SDL : Windows ............................................................................................................................................................................... Création d'un projet SDL sous Code::Blocks .......................................................................................................................................................... Création d'un projet SDL sous Visual C++ .............................................................................................................................................................. Créer un projet SDL : Mac OS (Xcode) ................................................................................................................................................................... Créer un projet SDL : Linux ..................................................................................................................................................................................... En résumé ............................................................................................................................................................................................................... Création d'une fenêtre et de surfaces ........................................................................................................................... Charger et arrêter la SDL ........................................................................................................................................................................................ SDL_Init : chargement de la SDL ............................................................................................................................................................................ SDL_Quit : arrêt de la SDL ...................................................................................................................................................................................... Canevas de programme SDL .................................................................................................................................................................................. Gérer les erreurs ..................................................................................................................................................................................................... Ouverture d'une fenêtre .......................................................................................................................................................................................... Choix du mode vidéo .............................................................................................................................................................................................. Mettre en pause le programme ............................................................................................................................................................................... Changer le titre de la fenêtre ................................................................................................................................................................................... Manipulation des surfaces ....................................................................................................................................................................................... Votre première surface : l'écran .............................................................................................................................................................................. Colorer une surface ................................................................................................................................................................................................. Dessiner une nouvelle surface à l'écran ................................................................................................................................................................. Centrer la surface à l'écran ..................................................................................................................................................................................... Exercice : créer un dégradé ....................................................................................................................................................................................
7. Correction ! ..............................................................................................................................................................................................................
8. « Je veux des exercices pour m'entraîner ! » .......................................................................................................................................................... En résumé ............................................................................................................................................................................................................... Afficher des images ....................................................................................................................................................... Charger une image BMP ......................................................................................................................................................................................... Le format BMP ........................................................................................................................................................................................................ Charger un Bitmap .................................................................................................................................................................................................. Associer une icône à son application ...................................................................................................................................................................... Gestion de la transparence ..................................................................................................................................................................................... Le problème de la transparence ............................................................................................................................................................................. Rendre une image transparente .............................................................................................................................................................................. La transparence Alpha ............................................................................................................................................................................................ Charger plus de formats d'image avec SDL_Image ................................................................................................................................................ Installer SDL_image sous Windows ........................................................................................................................................................................ Installer SDL_image sous Mac OS X ...................................................................................................................................................................... Charger les images ................................................................................................................................................................................................. En résumé ............................................................................................................................................................................................................... La gestion des événements .......................................................................................................................................... Le principe des événements ................................................................................................................................................................................... La variable d'événement ......................................................................................................................................................................................... La boucle des événements ..................................................................................................................................................................................... Récupération de l'événement .................................................................................................................................................................................. Analyse de l'événement .......................................................................................................................................................................................... Le code complet ...................................................................................................................................................................................................... Le clavier ................................................................................................................................................................................................................. Les événements du clavier ..................................................................................................................................................................................... Récupérer la touche ................................................................................................................................................................................................ Exercice : diriger Zozor au clavier ........................................................................................................................................................................... Charger l'image ....................................................................................................................................................................................................... Schéma de la programmation événementielle ........................................................................................................................................................ Traiter l'événement SDL_KEYDOWN ..................................................................................................................................................................... Quelques optimisations ........................................................................................................................................................................................... La souris .................................................................................................................................................................................................................. Gérer les clics de la souris ...................................................................................................................................................................................... Gérer le déplacement de la souris .......................................................................................................................................................................... Quelques autres fonctions avec la souris ............................................................................................................................................................... Les événements de la fenêtre ................................................................................................................................................................................. Redimensionnement de la fenêtre .......................................................................................................................................................................... Visibilité de la fenêtre .............................................................................................................................................................................................. En résumé ............................................................................................................................................................................................................... TP : Mario Sokoban ....................................................................................................................................................... Cahier des charges du Sokoban ............................................................................................................................................................................. À propos du Sokoban .............................................................................................................................................................................................. Le cahier des charges ............................................................................................................................................................................................. Récupérer les sprites du jeu ................................................................................................................................................................................... Le main et les constantes ....................................................................................................................................................................................... Les différents fichiers du projet ............................................................................................................................................................................... Les constantes : constantes.h ................................................................................................................................................................................. Le main : main.c ...................................................................................................................................................................................................... Le jeu ....................................................................................................................................................................................................................... Les paramètres envoyés à la fonction .................................................................................................................................................................... Les déclarations de variables .................................................................................................................................................................................. Initialisations ............................................................................................................................................................................................................ La boucle principale ................................................................................................................................................................................................ Fin de la fonction : déchargements ......................................................................................................................................................................... La fonction deplacerJoueur ..................................................................................................................................................................................... Chargement et enregistrement de niveaux ............................................................................................................................................................. chargerNiveau ......................................................................................................................................................................................................... sauvegarderNiveau .................................................................................................................................................................................................
9. L'éditeur de niveaux ................................................................................................................................................................................................ Initialisations ............................................................................................................................................................................................................ La gestion des événements .................................................................................................................................................................................... Blit time ! ................................................................................................................................................................................................................. Résumé et améliorations ........................................................................................................................................................................................ Alors résumons ! .....................................................................................................................................................................................................
10. Améliorez ! .............................................................................................................................................................................................................. Maîtrisez le temps ! ....................................................................................................................................................... Le Delay et les Ticks ............................................................................................................................................................................................... SDL_Delay .............................................................................................................................................................................................................. SDL_GetTicks ......................................................................................................................................................................................................... Utiliser SDL_GetTicks pour gérer le temps ............................................................................................................................................................. Les timers ................................................................................................................................................................................................................ Initialiser le système de timers ................................................................................................................................................................................ Ajouter un timer ....................................................................................................................................................................................................... En résumé ............................................................................................................................................................................................................... Écrire du texte avec SDL_ttf ......................................................................................................................................... Installer SDL_ttf ....................................................................................................................................................................................................... Comment fonctionne SDL_ttf ? ...............................................................................................................................................................................
11. Installer SDL_ttf ....................................................................................................................................................................................................... Configurer un projet pour SDL_ttf ........................................................................................................................................................................... La documentation .................................................................................................................................................................................................... Chargement de SDL_ttf ...........................................................................................................................................................................................
12. L'include ..................................................................................................................................................................................................................
13. Démarrage de SDL_ttf ............................................................................................................................................................................................
14. Arrêt de SDL_ttf ....................................................................................................................................................................................................... Chargement d'une police ........................................................................................................................................................................................ Les différentes méthodes d'écriture ........................................................................................................................................................................ Exemple d'écriture de texte en Blended .................................................................................................................................................................. Code complet d'écriture de texte ............................................................................................................................................................................. Attributs d'écriture du texte ...................................................................................................................................................................................... Exercice : le compteur ............................................................................................................................................................................................. En résumé ............................................................................................................................................................................................................... Jouer du son avec FMOD .............................................................................................................................................
15. Installer FMOD ........................................................................................................................................................................................................
16. Pourquoi FMOD ? ...................................................................................................................................................................................................
17. Télécharger FMOD ..................................................................................................................................................................................................
18. Installer FMOD ........................................................................................................................................................................................................ Initialiser et libérer un objet système ....................................................................................................................................................................... Inclure le header ...................................................................................................................................................................................................... Créer et initialiser un objet système ........................................................................................................................................................................ Fermer et libérer un objet système .......................................................................................................................................................................... Les sons courts ....................................................................................................................................................................................................... Trouver des sons courts .......................................................................................................................................................................................... Les étapes à suivre pour jouer un son .................................................................................................................................................................... Exemple : un jeu de tir ............................................................................................................................................................................................ Les musiques (MP3, OGG, WMA…) ....................................................................................................................................................................... Trouver des musiques ............................................................................................................................................................................................. Les étapes à suivre pour jouer une musique .......................................................................................................................................................... Code complet de lecture du MP3 ............................................................................................................................................................................ En résumé ............................................................................................................................................................................................................... TP : visualisation spectrale du son ................................................................................................................................ Les consignes .........................................................................................................................................................................................................
19. / Lire un MP3 .........................................................................................................................................................................................................
20. / Récupérer les données spectrales du son ..........................................................................................................................................................
21. / Réaliser le dégradé ............................................................................................................................................................................................. La solution ............................................................................................................................................................................................................... Idées d'amélioration ................................................................................................................................................................................................ Partie 4 : Les structures de données .............................................................................................. Les listes chaînées ........................................................................................................................................................ Représentation d'une liste chaînée ......................................................................................................................................................................... Construction d'une liste chaînée ............................................................................................................................................................................. Un élément de la liste .............................................................................................................................................................................................. La structure de contrôle ........................................................................................................................................................................................... Le dernier élément de la liste .................................................................................................................................................................................. Les fonctions de gestion de la liste ......................................................................................................................................................................... Initialiser la liste ....................................................................................................................................................................................................... Ajouter un élément .................................................................................................................................................................................................. Supprimer un élément ............................................................................................................................................................................................. Afficher la liste chaînée ........................................................................................................................................................................................... Aller plus loin ........................................................................................................................................................................................................... En résumé ............................................................................................................................................................................................................... Les piles et les files ....................................................................................................................................................... Les piles .................................................................................................................................................................................................................. Fonctionnement des piles ....................................................................................................................................................................................... Création d'un système de pile ................................................................................................................................................................................. Les files ................................................................................................................................................................................................................... Fonctionnement des files ........................................................................................................................................................................................ Création d'un système de file .................................................................................................................................................................................. À vous de jouer ! ..................................................................................................................................................................................................... En résumé ............................................................................................................................................................................................................... Les tables de hachage .................................................................................................................................................. Pourquoi utiliser une table de hachage ? ................................................................................................................................................................ Qu'est-ce qu'une table de hachage ? ...................................................................................................................................................................... Écrire une fonction de hachage .............................................................................................................................................................................. Gérer les collisions ..................................................................................................................................................................................................
22. L'adressage ouvert .................................................................................................................................................................................................. Le chaînage ............................................................................................................................................................................................................. En résumé ............................................................................................................................................................................................................... Ce que vous voyez là, c'est le langage informatique de votre ordinateur, appelé langage binaire (retenez bien ce mot !). Votre ordinateur ne connaît que ce langage-là et, comme vous pouvez le constater, c'est absolument incompréhensible. Donc voilà notre premier vrai problème : Comment parler à l'ordinateur plus simplement qu'en binaire avec des 0 et des 1 ? Votre ordinateur ne parle pas l'anglais et encore moins le français. Pourtant, il est inconcevable d'écrire un programme en langage binaire. Même les informaticiens les plus fous ne le font pas, c'est vous dire ! Eh bien l'idée que les informaticiens ont eue, c'est ! Code::Blocks (Windows, Mac OS, Linux)
23. Code::Blocks est un IDE libre et gratuit, disponible pour Windows, Mac et Linux. Code::Blocks n'est disponible pour le moment qu'en anglais. Cela ne devrait PAS vous repousser à l'utiliser. Croyez-moi, nous aurons quoi qu'il en soit peu affaire aux menus : c'est le langage C qui nous intéresse. Sachez toutefois que quand vous programmerez, vous serez de toute façon confrontés bien souvent à des documentations en anglais. Voilà donc une raison de plus pour s'entraîner à utiliser cette langue. Télécharger Code::Blocks (ex. : codeblocks-10.05mingw-setup.exe). L'autre version étant sans compilateur, vous auriez eu du mal à compiler vos programmes ! Si vous êtes sous Linux, choisissez le package qui correspond à votre distribution. Enfin, sous Mac, choisissez le fichier le plus récent de la liste. Ex. : codeblocks-10.05-p2-mac.zip. J'insiste là-dessus : si vous êtes sous Windows, téléchargez la version incluant mingw dans le nom du programme d'installation. Si vous prenez la mauvaise version, vous ne pourrez pas compiler vos programmes par la suite !
24. L'installation est très simple et rapide. Laissez toutes les options par défaut et lancez le programme. Vous devriez voir une fenêtre similaire à la fig. suivante. On distingue 4 grandes sections dans la fenêtre, numérotées sur l'image : 1. la barre d'outils : elle comprend de nombreux boutons, mais seuls quelques-uns nous seront régulièrement utiles. J'y reviendrai plus loin ;
25. Code::Blocks bien sûr, mais ce n'est pas le seul. Je vais vous présenter ici l'IDE le plus célèbre sous Mac : Xcode.
26. La partie de gauche correspond à l'arborescence de votre projet. Certaines sections regroupent les erreurs, les avertissements, etc. Xcode vous place automatiquement dans la section la plus utile, celle qui porte le nom de votre projet.
27. concerne, que l'on utilise l'une ou l'autre des écritures, ça ne changera rien pour nous. Inutile donc de s'y attarder, surtout que nous n'avons pas encore le niveau pour analyser ce que ça signifie. . Enregistrez le tout. Oui je sais, on n'a encore rien fait, mais enregistrez quand même, c'est une bonne habitude à prendre. Normalement, vous n'avez qu'un seul fichier source appelé main.c (le reste, ce 'on ne voit qu'en haut des fichiers source. Ces lignes sont facilement reconnaissables car elles commencent par un dièse #. Ces lignes spéciales, on les appelle directives de préprocesseur (un nom compliqué, n'est-ce pas ?). . Oui mais elles signifient quoi, ces lignes ? J'aimerais bien savoir quand même ! Le mot include en anglais signifie « inclure » en français. Ces lignes demandent d'inclure des fichiers au projet, c'est-à-dire 'écran. obligatoirement recompiler le programme pour qu'il marche chez vous.
28. Il y a deux dossiers, l'un avec l'exécutable (compilé sous Windows je le rappelle) et l'autre avec les sources.
29. Dans le cas de « Plus ou moins », les sources sont très simples : il y a juste un fichier main.c.
30. N'ouvrez pas le fichier main.c directement. Ouvrez d'abord votre IDE favori (Code::Blocks, Visual, etc.do... while. En théorie, une boucle while simple aurait pu fonctionner aussi, mais j'ai trouvé qu'utiliser do... while était plus logique. Pourquoi ? Parce que, souvenez-vous, do… while est une boucle qui s'exécute au moins une fois. Et nous, on sait qu'on veut demander le nombre à l'utilisateur au moins une fois (il ne peut pas trouver le résultat en moins d'un coup, ou alors c'est qu'il est super fort !). À chaque passage dans la boucle, on redemande à l'utilisateur d'entrer un nombre. On stocke le nombre qu'il propose dans nombreEntre. Puis, on compare ce nombreEntre au nombreMystere. Il y a trois possibilités : le nombre mystère est supérieur au nombre entré, on indique donc l'indice « C'est plus ! » ;
31. L'entrée: on fait « rentrer » des informations dans la fonction (en lui donnant des informations avec lesquelles travailler).
32. Les calculs : grâce aux informations qu'elle a reçues en entrée, la fonction travaille.
33. La sortie : une fois qu'elle a fini ses calculs, la fonction renvoie un résultat. C'est ce qu'on appelle la sortie, ou encore le retour. cela qu'en général on crée plusieurs fichiers par projet. Qu'est-ce qu'un projet, déjà ? Non, vous n'avez pas déjà oublié ? Bon : je vous le réexplique, parce qu'il est important qu'on soit bien d'accord sur ce terme. Un projet, c'est l'ensemble des fichiers source de votre programme. Pour le moment, nos projets n'étaient composés que d'un fichier source. Regardez dans votre IDE, généralement c'est sur la gauche (fig. suivante). .c : c'est celui qui contient la fonction main. En général dans mes programmes, je ne mets que le main dans main.c. Pour information, ce n'est pas du tout une obligation, chacun s'organise comme il veut. Pour bien me suivre, je vous conseille néanmoins de faire comme moi. Mais pourquoi avoir créé plusieurs fichiers ? Et comment je sais combien de fichiers je dois créer pour mon projet ? Ça, c'est vous qui choisissez. En général, on regroupe dans un même fichier des fonctions ayant le même thème. Ainsi, dans le fichier editeur.c j'ai regroupé toutes les fonctions concernant l'éditeur de niveau ; dans le fichier jeu.c, j'ai regroupé toutes les fonctions concernant le jeu lui-même, etc. stdlib.h, c'est donc qu'ils existent quelque part et qu'on peut aller les chercher, non ? Oui, bien sûr ! Ils sont normalement installés là où se trouve votre IDE. Dans mon cas sous Code::Blocks, je les trouve là : C:\Program Files\CodeBlocks\MinGW\include Il faut généralement chercher un dossier include.
34. Là-dedans, vous allez trouver de très nombreux fichiers. Ce sont des headers (.h) des bibliothèques standard, c'est-à-dire des bibliothèques disponibles partout (que ce soit sous Windows, Mac, Linux…). fonctions standard, comme printf par exemple. Ok, je sais maintenant où se trouvent les prototypes des fonctions standard. Mais comment pourrais-je voir le code source de ces fonctions ? Où sont les .c ? Vous ne les avez pas ! En fait, les fichiers .c sont déjà compilés (en code binaire, c'est-à-dire en code machine). Il est donc totalement impossible de les lire. Vous pouvez retrouver les fichiers compilés dans un répertoire appelé lib (c'est l'abréviation de library qui signifie « bibliothèque » en français). Chez moi, on peut les trouver dans le répertoire : C:\Program Files\CodeBlocks\MinGW\lib Les fichiers compilés des bibliothèques ont l'extension .a sous Code::Blocks (qui utilise le compilateur appelé mingw) et ont l'extension .lib sous Visual C++ (qui utilise le compilateur Visual). N'essayez pas de les lire : ce n'est absolument pas comestible pour un humain. En résumé, dans vos fichiers .c, vous incluez les .
35. C'est d'ailleurs justement là un des rôles principaux d'un système d'exploitation : on dit qu'il alloue de la mémoire aux programmes. 'âge, on peut utiliser la fonction printf : Dans ce schéma, la variable age a été placée à l'adresse 177450 (vous voyez d'ailleurs que sa valeur est 10), et le pointeur pointeurSurAge a été placé à l'adresse 3 (c'est tout à fait le fruit du hasard). 'aide d'un printf : 1. une variable nombre est créée dans le main. On lui affecte la valeur 5. Ça, vous connaissez ;
36. maintenant qu'on a un pointeur sur nombre, on peut modifier directement la variable nombre en mémoire ! Il suffit d'utiliser *pointeurSurNombre pour désigner la variable nombre ! Pour l'exemple, on fait un simple test : on multiplie la variable nombre par 3 ;
37. Bien sûr, j'aurais pu faire un simple return comme on a appris à le faire dans le chapitre sur les fonctions. Mais l'intérêt, là, c'est que de cette manière, en utilisant des pointeurs, on 0 : tableau[0], tableau[1], tableau[2], etc. « inclusions infinies ». Une inclusion infinie ? C'est-à-dire ?
38. Imaginez, c'est très simple. J'ai un fichier A.h et un fichier B.h. Le fichier A.h contient un include du fichier B.h. Le fichier B est donc inclus dans le fichier A. Mais, et c'est là que ça commence à coincer, supposez
39. il lit B.h pour l'inclure, et là il voit qu'il faut inclure A.h ;
40. il inclut donc A.h dans B.h, mais dans A.h on lui indique qu'il doit inclure B.h ! 4. rebelote, il va voir B.h et voit à nouveau qu'il faut inclure A.h ;
41. 'inclusions, le préprocesseur s'arrêtera en disant « J'en ai marre des inclusions ! » ce qui fera planter votre compilation. Comment diable faire pour éviter cet affreux cauchemar ? Voici l'astuce. Désormais, je vous demande de faire comme ça dans TOUS vos fichiers .h sans exception : Code : C #ifndef DEF_NOMDUFICHIER //
42. Comprenez-vous bien comment ce code fonctionne ? La première fois qu'on m'a présenté cette technique, j'étais assez désorienté : je vais essayer de vous l'expliquer. Imaginez que le fichier .h est inclus pour la première fois. Le préprocesseur lit la condition « Si la constante DEF_NOMDUFICHIER n'a pas été définie ». Comme c'est la première fois que le fichier est lu, la constante n'est pas définie, donc le préprocesseur entre à l'intérieur du if. La première instruction qu'il rencontre est justement : Code : C #define DEF_NOMDUFICHIER Maintenant, la constante est définie. La prochaine fois que le fichier sera inclus, la condition ne sera plus vraie et donc le fichier ne risque plus d'être inclus à nouveau. Bien entendu, vous appelez votre constante comme vous voulez. Moi, je l'appelle DEF_NOMDUFICHIER par habitude. une variable, on dit qu'on demande à allouer de la mémoire : Code : C int monNombre = 0; Lorsque le programme arrive à une ligne comme celle-ci, il se passe en fait les choses suivantes : 1. votre programme demande au système d'exploitation (Windows, Linux, Mac OS…) la permission d'utiliser un peu de mémoire ;
43. le système d'exploitation répond à votre programme en lui indiquant où il peut stocker cette variable (il lui donne l'adresse qu'il lui a réservée) ;
44. lorsque la fonction est terminée, la variable est automatiquement supprimée de la mémoire. Votre programme dit au système d'exploitation : « Je n'ai plus besoin de l'espace en mémoire que tu m'avais réservé à telle adresse, merci ! L'histoire ne précise pas si le programme dit vraiment « merci » à l'OS, mais c'est tout dans son intérêt parce que c'est l'OS qui contrôle la mémoire ! Jusqu'ici, les choses étaient automatiques. Lorsqu'on déclarait une variable, le système d'exploitation était automatiquement appelé par le programme. créer (char, int, double, float…), vous avez besoin de plus ou moins de mémoire. En effet, pour stocker un nombre compris entre -128 et 127 (un char), on n'a besoin que d'un octet en mémoire. C'est tout petit. En revanche, un int occupe généralement 4 octets en mémoire. Quant au double, il occupe 8 octets. Le problème est… que ce n'est pas toujours le cas. Cela dépend des machines : peut-être que chez vous un int occupe 8 octets, qui sait ? Notre objectif ici est de vérifier quelle taille occupe chacun des types sur votre ordinateur. Il y a un moyen très facile pour savoir cela : utiliser l'opérateur sizeof(). , et surtout : per-sé-vé-rez ! La solution (1 : le code du jeu)
45. Si vous lisez ces lignes, c'est soit que vous avez terminé le programme, soit que vous n'arrivez pas à le terminer. temps (quelques minutes, quelques heures, quelques jours ?), mais ça n'a jamais été une course.
46. J'ai fait plusieurs erreurs en codant : j'ai oublié à un moment d'initialiser une variable correctement, j'ai oublié d'écrire le prototype d'une fonction ou encore de supprimer une variable qui ne servait plus dans mon code. J'ai même -je l'avoue -oublié un bête point-virgule
47. D'abord je vais vous montrer comment j'ai fait le code du jeu lui-même, en fixant le mot caché directement dans le code. J'ai choisi le mot MARRON car il me permet de tester si je gère bien les lettres en double, comme le R ici.
48. 'est pas NULL. Si c'est le cas, c'est que l'allocation a échoué. Dans ce cas, on arrête immédiatement le programme (on fait appel à exit()).
49. Si les lignes suivantes sont lues, c'est donc que tout s'est bien passé.
50. Le problème, c'est que le reste de la chaîne qui n'a pas pu être lu, à savoir « ard Albert 1er », n'a pas disparu ! Il est toujours dans le buffer. II, nous avons uniquement utilisé la bibliothèque standard (stdlib.h, stdio.h, string.h, time.'autres programmeurs. Certaines sont bonnes, d'autres moins, certaines sont payantes, d'autres gratuites, etc. l'idéal
51. J'ai rapidement constaté que la majorité de mes lecteurs souhaitait découvrir comment ouvrir des fenêtres, créer des jeux, etc.
52. Enfin, si vous aimez la console on peut continuer longtemps, si vous voulez… Non ? Ah bon, tiens c'est curieux ! Quant à moi, non seulement j'ai bien envie de vous montrer comment on peut faire tout ça, mais en plus je tiens absolument à vous faire pratiquer. En effet, nous avons bien fait quelques TP dans les parties I et II, mais ce n'est pas assez. C'est en forgeant que l'on devient forgeron, et c'est en programmant que euh… Bref, vous m'avez compris ! Je suis donc parti pour vous à la recherche d'une bibliothèque à la fois simple et puissante pour que vous puissiez rapidement réaliser vos rêves les plus fous (presque) sans douleur (tout est relatif, bien sûr !). faisant bouger une image, vous pouvez faire se déplacer un personnage. En affichant plusieurs images d'affilée, vous pouvez créer une animation. En combinant plusieurs images côte à côte, vous pouvez créer un véritable jeu. SDL, c'est la 2D. Elle n'est en effet pas conçue pour la 3D. Voici une liste de jeux que l'on peut parfaitement concevoir en SDL (ce n'est qu'une petite liste, tout est possible a priori tant que ça reste de la 2D) : Casse-briques ; Bomberman ; Tetris ; jeux de plate-forme : Super Mario Bros, Sonic, Rayman… RPG 2D : Zelda, les premiers Final Fantasy, etc.
53. Il m'est impossible de faire une liste complète, la seule limite ici étant l'imagination. J'ai d'SDL, rendez-vous dans le menu à gauche, section Download. 'intérieur, mais actuellement ça ne vous apportera rien. Pire, ça vous embrouillera et ce n'est pas le but. Runtime libraries : ce .lib ; mingw32 : pour ceux qui utilisent Code::Blocks (il y aura donc des fichiers .a).
54. La particularité, c'est que les « Development libraries » contiennent tout ce qu'il faut : les .h et .a (ou .lib) bien sûr, mais SDL : Windows L'installation d'une bibliothèque est en général un petit peu plus compliquée que les installations dont vous avez l'habitude. Ici, il n'y a pas d'installeur automatique qui vous demande simplement de cliquer sur Suivant -Suivant -Suivant - Terminer. En général, installer une bibliothèque est assez difficile pour un débutant. Pourtant, si ça peut vous remonter le moral, l'installation de la SDL est beaucoup plus simple que bien d'autres bibliothèques que j'ai eu l'occasion d'utiliser (en général on ne vous donne que le code source de la bibliothèque, et c'est à vous de la recompiler !).
55. En fait, le mot « installer » n'est peut-être pas celui qui convient le mieux. Nous n'allons rien installer du tout : nous voulons simplement arriver à créer un nouveau projet de type SDL avec notre IDE. Or, selon l'IDE de Code::Blocks, dans un sous-dossier SDL (fig. suivante).
56. Dans mon cas, la SDL sera installée dans le dossier : C:\Program Files\CodeBlocks\SDL-1.2.13
57. Retenez bien le nom du dossier dans lequel vous l'avez installée, vous allez en avoir besoin pour configurer Code::Blocks.
58. Maintenant, il va falloir faire une petite manipulation pour simplifier la suite. Allez dans le sous-dossier include/SDL (dans mon cas, il se trouve dans C:\Program Files\CodeBlocks\SDL-1.2.13\include\SDL). Vous devriez y voir de nombreux petits fichiers .h. Copiez-les dans le dossier parent, c'est-à-dire dans : C:\Program Files\CodeBlocks\SDL-1.2.13\include
59. La SDL est installée ! Il faut maintenant configurer Code::Blocks. 2/ Création du projet SDL Ouvrez maintenant Code::Blocks et demandez à créer un nouveau projet. 'exécutable. Double-cliquez sur votre .exe : si tout va bien, il ne devrait rien se passer. Sinon, s'il y a une erreur c'est probablement que le fichier SDL.dll ne se trouve pas dans le même dossier. Créer un projet SDL : Mac OS (Xcode) , vous verrez soit Intel, soit PowerPC. Une fois le fichier téléchargé, montez-le (double-cliquez dessus) ; -lite ; gardez-le ouvert, nous nous en servirons par la suite.
60. Maintenant, créez un nouveau projet Cocoa Application, puis cliquez sur Next. Dans Product Name, nommez votre projet (« , vous pouvez supprimer tous les fichiers qui ne nous serviront pas : AppDelegate.h, AppDelegate.m, MainMenu.xib, InfoPlist.strings, main.m et Credits.rtf (figure suivante). 'onglet Summary. Dans Application Category, vous pouvez mettre ce que vous voulez, mais ça n'apporte pas grand chose, c'est pour l'AppStore. 'affiche, cochez la case Copy items into destination group's folder (if needed). Dernière ligne droite : créez un fichier main.c. Allez dans le menu File > New > New File, puis dans C and C++.
61. Sélectionnez C File puis Next. Nommez votre fichier et le tour est joué ! Créer un projet SDL : Linux Si vous compilez sous Linux avec un IDE, il faudra modifier les propriétés du projet (la manipulation sera quasiment la même). Si vous utilisez Code::Blocks (qui
62. Ensuite, vous pourrez utiliser les commandes suivantes dans la console : 'agit, et justement c'est ça qui est bien. Vous avez juste besoin d'écrire la constante, c'est plus facile à lire et à retenir. La fonction SDL_Init regardera le nombre qu'elle reçoit et en fonction de cela, elle saura quels systèmes elle doit charger. Maintenant, si vous faites : Code : C SDL_Init(SDL_INIT_EVERYTHING);
63. … 'audio et la vidéo seulement. Dois-je utiliser SDL_INIT_EVERYTHING ? Vous n'allez pas utiliser SDL_INIT_EVERYTHING juste parce que vous avez besoin de deux modules, pauvres fous ! Heureusement, on peut combiner les options à l'aide du symbole | (la barre verticale). le moment, notre fenêtre a un titre par défaut : (SDL_app sur la fig. suivante). Que diriez-vous de changer cela ? C'est extrêmement simple, il suffit d'utiliser la fonction SDL_WM_SetCaption. 'heure avec la fonction SDL_WM_SetCaption en plus : Code : C int main(int argc, char *argv[])
64. SDL_Init(SDL_INIT_VIDEO);
65. SDL_SetVideoMode(640, 480, 32, SDL_HWSURFACE);
66. SDL_WM_SetCaption("Ma super fenêtre SDL !", NULL);
67. dans l'ordre : un pointeur sur la surface dans laquelle on doit dessiner (par exemple ecran) ;
68. la
69. En résumé : Code : C SDL_FillRect(surface, NULL, couleur);
70. La long, tout simplement ?
71. La SDL est une bibliothèque multi-plates-formes. Or, comme vous le savez maintenant, la taille occupée par un int ou un long peut varier selon votre OS. Pour s'assurer que le nombre occupera toujours la même taille en mémoire, la SDL a donc « inventé » des types pour stocker des entiers qui ont la même taille sur tous les systèmes. Il y a par exemple : Uint32 : un entier de longueur 32 bits, soit 4 octets (je rappelle que 1 octet = 8 bits) ;
72. Uint16 , comme un int. D'accord, mais comment je sais quel nombre je dois mettre pour utiliser la couleur verte, azur, gris foncé ou encore jaune pâle à points roses avec des petites fleurs violettes (bien entendu, cette dernière couleur n'existe pas) ? Il existe une fonction qui sert à ça : SDL_MapRGB. Elle prend quatre paramètres : le format des couleurs. Ce format dépend du nombre de bits / pixel que vous avez demandé avec SDL_SetVideoMode. Vous pouvez le récupérer, il est stocké dans la sous-variable ecran->format ; 'abscisse ; y : l'ordonnée. Il faut savoir que le point de coordonnées (0, 0) est situé tout en haut à gauche. En bas à droite, le point a les coordonnées (640, 480'écran : C'est mignon, non ? Et le pire c'est qu'il suffit de quelques petites boucles seulement pour y arriver. Pour faire ça, on va devoir créer 256 surfaces (256 lignes) ayant les composantes rouge-vert-bleu suivantes : Code : C (0, 0, 0) // Noir (1, 1, 1) // . Cependant, pour le moment nous ne pouvons créer que des surfaces unies, c'est-à-dire ayant la même couleur, ce qui est un peu monotone.
73. Dans ce chapitre, nous allons apprendre à charger des images dans des surfaces, que ce soit des BMP, des PNG, des GIF ou des JPG. La manipulation d'images est souvent très motivante car c'est en assemblant ces images (aussi appelées « sprites ») que l'on
74. Le Bitmap est un format non compressé (contrairement aux JPG, PNG, GIF, etc.).
75. Concrètement, cela signifie les choses suivantes : le fichier est très rapide à lire, contrairement aux formats compressés qui doivent être décompressés, ce qui prend un peu plus de temps ; la qualité de l'image est parfaite. Certains formats compressés (je pense au JPG plus particulièrement, car les PNG et GIF n'altèrent pas l'image) détériorent la qualité de l'image, ce n'est pas le cas du BMP ; 'exécution de votre programme, il vaut mieux utiliser des BMP : certes le fichier est plus gros, mais il se chargera plus vite qu'un GIF par exemple. Zozor, ça aurait été plus joli ? Eh bien non, le problème ici c'est que notre image est forcément rectangulaire, donc si on la colle sur la scène on voit son fond, ce qui ne rend pas très bien. Heureusement, la SDL gère la transparence ! Rendre une image transparente Étape 1 : préparer l'image Pour commencer, il faut préparer l'image que vous voulez blitter sur la scène. Le format BMP ne gère pas la transparence, contrairement aux GIF et PNG. Il va donc falloir utiliser une astuce. , téléchargez SDL_image-devel-1.2.10-VC.zip, et ce même si vous n'utilisez pas Visual C++ ! Installation Dans ce .zip, vous trouverez : SDL_image.h : le seul header dont a besoin la bibliothèque SDL_Image. Placez-le dans C:\Program Files\CodeBlocks\SDL-1.2.13\include, c'est-à-dire à côté des autres headers de la SDL ; SDL_image.lib : copiez dans C:\Program Files\CodeBlocks\SDL-1.2.13\lib. Oui, je sais, je vous ai dit que normalement les .lib étaient des fichiers réservés à Visual, mais ici exceptionnellement le .lib fonctionnera même avec le compilateur mingw ; plusieurs DLL : placez-les toutes dans le dossier de votre projet (à côté de SDL.dll, donc).
76. Ensuite, vous devez modifier les options de votre projet pour « linker » avec le fichier SDL_image.lib. Si vous êtes sous Code::Blocks par exemple, allez dans le menu Projects / Build options. Dans l'onglet Linker, cliquez
77. Concrètement, qu'est-ce qu'un événement ? C'est un « signal » envoyé par un périphérique (ou par le système d'exploitation) à votre application. Voici quelques exemples d'événements courants : quand l'utilisateur appuie sur une touche du clavier ; l'ordinateur « Si l'utilisateur clique à cet endroit, fais ça, sinon fais cela… S'il bouge la souris, fais ceci. S'il appuie sur la touche Q, arrête le programme… », etc. Le principe des événements Pour nous habituer aux événements, nous allons apprendre à traiter le plus simple d'entre eux : la demande de fermeture du programme. C'est un événement qui se produit lorsque l'utilisateur clique sur la croix pour fermer la fenêtre (fig. suivante).
78. C'est vraiment l'événement le plus simple. En plus, c'est un événement que vous avez utilisé jusqu'ici sans vraiment le savoir, car (juste une seule, rassurez-vous) de type SDL_Event. Appelez-la comme vous voulez : moi, je vais l'appeler event, ce qui signifie « événement » en anglais. En revanche, si vous utilisez SDL_PollEvent, votre programme va parcourir votre boucle while et rappeler SDL_PollEvent indéfiniment jusqu'à ce qu'un événement se soit produit. À tous les coups, vous utiliserez 100 % du processeur. Mais alors, il faut tout le temps utiliser SDL_WaitEvent si cette fonction utilise moins le processeur, non ? 'adresse : Code : C SDL_WaitEvent(&event);
79. Après appel de cette fonction, la variable event contient obligatoirement un événement. Cela n'aurait pas forcément été le cas si on avait utilisé SDL_PollEvent : cette fonction aurait pu renvoyer « Pas d'événement ». Analyse de l'événement Maintenant, nous disposons d'une variable event qui contient des informations sur l'événement qui s'est produit. Il faut regarder la sous-variable event.type et faire un test sur sa valeur. Généralement on utilise un switch pour tester l'événement. Mais comment sait-on quelle valeur correspond à l'événement « Quitter », par exemple ?
80. La SDL nous fournit des constantes, ce qui simplifie grandement l'écriture du programme. 'événement qu'on a reçu : on effectue certaines actions, certains calculs.
81. première chose à faire : on efface l'écran avec un SDL_FillRect. Si on ne le faisait pas, on aurait des « traces » de l'ancien écran qui subsisteraient, et forcément, ce ne serait pas très joli ;
82. ensuite, on fait tous les blits nécessaires pour coller les surfaces sur l'écran ;
83. enfin, une fois que c'est fait, on met à jour l'affichage aux yeux de l'utilisateur, en appelant la fonction SDL_Flip(ecran). 'événement, on effectue différentes actions. Ici, je mets à jour les coordonnées de Zozor pour donner l'impression qu'on le déplace.
84. Ensuite, après le switch vous devez mettre à jour votre écran comme suit.
85. Premièrement, vous effacez l'écran via un SDL_FillRect (de la couleur de fond que vous voulez).
86. Ensuite, vous blittez vos surfaces sur l'écran. Ici, je n'ai eu besoin de blitter que Zozor car il n'y a que lui. Vous noterez, et c'est très important, que je blitte Zozor à positionZozor ! C'est là que la différence se fait : si j'ai mis à jour positionZozor auparavant, alors Zozor apparaîtra à un autre endroit et on aura l'impression qu'on l'a déplacé !
87. Enfin, toute dernière chose à faire : SDL_Flip. Cela ordonne la mise à jour de l'écran aux yeux de l'utilisateur. On peut donc déplacer Zozor où l'on veut sur l'écran, maintenant (fig. suivante) ! Quelques optimisations Répétition des touches Pour l'instant, notre 10 ms : Code : C SDL_EnableKeyRepeat(10, 10);
88. Maintenant'image. Pourquoi l'image scintillerait-elle ? Parce que quand vous dessinez à l'écran, l'utilisateur « voit » quand vous dessinez et donc quand l'écran s'efface. Même si ça va très vite, notre cerveau perçoit un clignotement et c'est très désagréable. La technique du double buffering consiste à utiliser deux « écrans » : l'un est réel (celui que l'utilisateur est en train de voir sur son moniteur), l'autre est virtuel (c'est une image que l'ordinateur est en train de construire en mémoire). Ces deux écrans alternent : l'écran A est affiché pendant que l'autre (l'écran B) en « arrière-plan » prépare l'image suivante (fig.
89. Une fois que l'image en arrière-plan (l'écran B) a été dessinée, on briques, les caisses, les objectifs, etc.
90. La case en bas à droite (la toute dernière) est stockée dans carte[11][11].
91. Selon la valeur de la case (qui est un nombre entier), on sait si la case contient un mur, une caisse, un objectif, etc.constantes HAUT, BAS, GAUCHE, DROITE. Le fait d'utiliser les constantes rend ici -comme vous le voyez -le code plus clair. On aurait très bien pu écrire mario[0], mais c'est quand même plus lisible d'avoir mario[HAUT] par exemple ! Cette fonction prend un paramètre : la carte. Là encore, il faut préciser la taille de la seconde dimension car il s'agit d'un tableau à deux dimensions. La fonction renvoie un booléen : « vrai » si le chargement a réussi, « faux » si c'est un échec.
92. Ou bien : Téléchargez la version compilée pour linux au format .tar.gz (64 Ko)
93. Le programme d'installation a été créé à l'aide d'Inno Setup. Pour plus d'informations, voir le cours Créer une installation.
94. Puis, et c'est vraiment ce qu'il ne faut pas oublier, on place le temps « actuel » dans le temps « précédent ». En effet, imaginez le prochain tour de boucle : le temps « actuel » aura changé, et on pourra le comparer au temps précédent. À nouveau, on pourra vérifier si 30 ms se seront écoulées et bouger Zozor. détail près : la fonction SDL_WaitEvent. Elle était très pratique jusqu'ici, puisqu'on n'avait pas à gérer le temps. Cette fonction mettait en pause le programme (un peu à la
95. SDL_WaitEvent ! La solution ? SDL_PollEvent. Je vous avais déjà présenté cette fonction : contrairement à SDL_WaitEvent, elle renvoie une valeur, qu'il y ait eu un événement ou non. On dit que la fonction n'est pas bloquante : elle ne met pas en pause le programme, la boucle infinie va donc tourner tout le temps.
96. Les timers L'utilisation des timers est un peu complexe. Elle fait intervenir une notion qu'on n'a pas vue jusqu'ici : les pointeurs de fonctions. Il n'est pas indispensable d'utiliser les timers : si vous les trouvez trop délicats à utiliser, vous pouvez passer votre chemin sans problème. la réponse : c'est non.
97. Cependant, il y a quand même moyen d'y arriver. Il suffit d'utiliser… la ruse ! On peut par exemple blitter des images de lettres une à une à l'écran. Ça fonctionne, mais ce n'est pas ce qu'il y a de plus pratique.
98. Heureusement, il y a plus simple : on peut utiliser la bibliothèque SDL_ttf. C'est une bibliothèque qui vient s'ajouter par-dessus la SDL, tout
99. Installer SDL_ttf Il faut savoir que, comme SDL_image, SDL_ttf est une bibliothèque qui nécessite que la SDL soit installée. Bon : si à ce stade du cours vous n'avez toujours pas installé la SDL, c'est grave, donc je vais supposer que c'est déjà fait ! Tout comme SDL_image, SDL_ttf est une des bibliothèques liées à la SDL les plus populaires (c'est-à-dire qu'elle est très
100. C++, mais en fait, exceptionnellement, le fichier .lib livré ici marche aussi avec mingw32, il fonctionnera donc sous Code::Blocks. résumé : si vous avez un texte qui change souvent, comme un compte à rebours, utilisez Solid ; 'écriture, il y a quatre fonctions. Chaque fonction écrit le texte à l'aide d'un charset différent, c'est-à-dire d'une palette de caractères différente. Ces quatre fonctions sont : Latin1 ; UTF8 ; Unicode ;
101. Unicode Glyph.
102. L'idéal est d'utiliser l'Unicode car c'est un charset gérant la quasi-totalité des caractères existant sur Terre. Toutefois, utiliser l'Unicode n'est pas toujours forcément simple (un caractère prend plus que la taille d'un char en mémoire), nous ne verrons donc pas comment l'utiliser ici.
103. A priori, si votre programme est écrit en français le mode Latin1 suffit amplement, vous pouvez vous contenter de celui-là.
104. Les trois fonctions utilisant le charset Latin1 sont : TTF_RenderText_Solid ;
105. N'hésitez pas à télécharger ce projet si vous souhaitez l'étudier en détail et l'améliorer. Il n'est pas encore parfait : on pourrait par utilisent FMOD ; parmi les plus connus : Starcraft II, World of Warcraft : Cataclysm, Crysis 2, etc. Il existe plusieurs versions de FMOD, en particulier celle destinée à une utilisation sous des OS dits habituels (Linux, Windows, Mac…), elle s'appelle FMOD Ex Programmers API.
106. Installez FMOD Ex sur votre disque. Les fichiers dont nous avons besoin seront placés dans un répertoire similaire à celui-ci : C:\Program Files\FMOD SoundSystem\FMOD Programmers API Win32\api.
107. Dans ce dossier, vous trouverez la DLL de FMOD Ex (fmodex.dll) à placer dans le répertoire de votre projet. L'autre DLL, fmodexL.dll, sert à effectuer du débogage. Nous n'en ferons pas ici. Retenez surtout que c'est le fichier fmodex.dll que vous devrez livrer avec votre programme.
108. Dans le dossier api/inc, vous trouverez les .h. Placez-les à côté des autres .h dans le dossier de votre IDE. Par exemple Code Blocks/mingw32/include/fmodex (j'ai créé un dossier spécial pour FMOD comme pour SDL).
109. Dans le dossier api/lib, récupérez le fichier qui correspond à votre compilateur. Un fichier texte doit vous indiquer quel fichier vous devez prendre : Si vous utilisez Code Blocks, donc le compilateur mingw, copiez libfmodex.a dans le dossier lib de votre IDE. Dans le cas de Code Blocks, c'est le dossier CodeBlocks/mingw32/lib ; Si vous utilisez Visual C++, récupérez le fichier fmodex_vc.lib.
110. Enfin, et c'est peut-être le plus important, il y a un dossier documentation dans le répertoire de FMOD Ex. Normalement, des raccourcis ont été créés dans le menu Démarrer vers cette documentation. Gardez un oeil dessus, car . Là encore, c'est comme les autres fois : vous ouvrez votre projet avec votre IDE favori et vous ajoutez le fichier .a (ou .lib) à la liste des fichiers que le linker doit récupérer. Sous Code Blocks (j'ai l'impression de me répéter), menu Project > Build Options, onglet Linker, cliquez sur Add et étape : créer un pointeur de type FMOD_SOUND qui représentera notre son. Code : C FMOD_SOUND *tir = NULL;
111. Charger le son Deuxième étape : charger le son avec la fonction FMOD_System_CreateSound. Elle prend… 5 paramètres : Un objet système dont on a parlé précédemment. Bien sûr cet objet doit être prêt à l'emploi (déclaré, alloué et initialisé). Le nom du fichier son à charger. Il peut être de format WAV, MP3, OGG, etc. Toutefois, il vaut mieux charger des sons courts (quelques secondes maximum) plutôt que des sons longs. En effet, la fonction chargera et décodera tout le son en mémoire, ce chargement : Code : C FMOD_System_CreateSound(system, "pan.wav", FMOD_CREATESAMPLE, 0, &tir);
112. Ici, je charge le son pan.wav. Le pointeur tir fera référence à ce son par la suite. 'on ait. Les musiques (MP3, OGG, WMA…)
113. En théorie, le flag FMOD_CREATESAMPLE permet de charger n'importe quel type de son, y compris les formats compressés MP3, OGG, WMA. Le problème concerne les sons « longs », c'est-à-dire les musiques.
114. Là, on rentre en terrain miné, épineux, explosif (comme vous préférez). En effet, la plupart des musiques et chansons que l'on connaît sont soumises au droit d'auteur. Même si vous ne faites qu'un petit programme, il faut verser une redevance à la SACEM (en France du moins).
115. Donc, mis à part les MP3 soumis à droit d'auteur, que nous reste-t-il ? Heureusement, il
116. J'ai donc téléchargé l'album et je vais utiliser la chanson « Home » au format MP3. façon : Code : C FMOD_System_CreateSound(system, "ma_musique.mp3", FMOD_SOFTWARE | FMOD_2D | FMOD_CREATESTREAM, 0, &sound);
117. Et
118. Depuis FMOD Ex, il y a eu un petit changement : à partir du numéro de canal, on utilise une fonction qui fournit un pointeur vers ce canal. L'idée est restée la même, seule l'implémentation a changé. canal n°9, il faut faire : Code : C FMOD_CHANNEL *channel; FMOD_System_GetChannel(system, 9, &channel);
119. Rien 'adresse du pointeur où l'on veut stocker l'information voulue. Une fois qu'on aura notre pointeur de canal, on pourra facilement manipuler la musique (modifier le volume, mettre en pause…). 'écrire nous-mêmes.
120. Pour ce faire, il faut suivre ces étapes méthodiquement dans l'ordre :
121. 'écran, vous devrez donc bloquer la surface ecran : Code : C SDL_LockSurface(ecran);
122. copiez-la simplement dans votre programme pour pouvoir l'utiliser : Code : C void setPixel(SDL_Surface *surface, int x, int y, Uint32 pixel) { int bpp = surface->format->BytesPerPixel; 'espace, il sera impossible d'agrandir ce tableau. De même, il n'est pas possible d'insérer une case au milieu du tableau. 'aide de pointeurs. On pourrait les représenter comme ceci : Chaque élément peut contenir ce que l'on veut : un ou plusieurs int, double… En plus de cela, chaque élément possède un pointeur vers l'élément suivant (fig. suivante). 'une liste chaînée, correspondant à la fig. suivante que nous avons vue plus tôt. Que contient cette structure ? Une donnée, ici un nombre de type int : on pourrait remplacer cela par n'importe quelle autre donnée (un double, un
123. c'est-à-dire le nombre d'éléments qu'elle contient.
124. Ici, les choses se compliquent un peu. Où va-t-on ajouter un nouvel élément ? Au début de la liste, à la fin, au milieu ? précis : le dernier élément que vous avez stocké doit être le premier à ressortir. Pour vous donner un exemple concret, votre système d'exploitation utilise ce type d'algorithme pour retenir l'ordre dans lequel les fonctions ont été appelées. Imaginez un exemple : 1. votre programme commence par la fonction main (comme toujours) ;
125. cette fonction jouer fait appel à son tour à la fonction charger ;
126. une fois que la fonction charger est terminée, on retourne à la fonction jouer ;
127. une fois que la fonction jouer est terminée, on retourne au main ;
128. enfin, une fois le main terminé, il n'y a plus de fonction à appeler, le programme s'achève.
129. Pour « retenir » l'ordre dans lequel les fonctions ont été appelées, votre ordinateur crée une pile de ces fonctions au fur et à mesure (fig. suivante).
130. Voilà un exemple concret d'utilisation des piles. Grâce à cette technique, votre ordinateur sait à quelle fonction il doit retourner. Il peut empiler 100 fonctions d'affilée s'il le faut, il retrouvera toujours le main en bas ! L'ajout se fait en début de pile car, comme on l'a vu, il est impossible de le faire au milieu d'une pile. C'est le principe même de son fonctionnement, on ajoute toujours par le haut.
131. De ce fait, contrairement aux listes chaînées, on C que vous connaissez bien, dorénavant. Leur gros avantage ? Elles permettent de retrouver instantanément un élément précis, que la table contienne 100, 1 000, 10 000 cases ou plus encore ! Pourquoi utiliser une table de hachage ? Partons du problème que peuvent nous poser les listes chaînées. Celles-ci sont particulièrement souples, nous avons pu le constater : il est possible d'ajouter ou de supprimer des cases à tout moment, alors qu'un tableau est « figé » une fois qu'il a été créé. Toutefois, comme je vous le disais en introduction, les listes chaînées ont quand même un gros défaut : si
132. Néanmoins, pour évaluer l'efficacité d'un algorithme, on doit toujours envisager le pire des cas. Et le pire, c'est Luc. Ici, on dit que l'algorithme de recherche d'un élément a une complexité en , car 'élément d'indice 2 dans mon tableau, il me suffisait d'écrire ceci : Code : C int tableau[4] = {12, 7, 14, 33}; printf("%d", tableau[2]);
133. Si on lui donne tableau[2], l'ordinateur », en fait ? Mais dans ce cas, on perd l'avantage des listes chaînées qui nous permettaient d'ajouter et de retirer des cases à tout moment ! En effet, les listes chaînées sont plus flexibles. Les tableaux, eux, permettent un accès plus rapide. 'a pas beaucoup parlé jusqu'ici : les cases sont identifiées par des numéros qu'on appelle des indices. Il n'est pas possible de demander à l'ordinateur : « Dis-moi quelles sont les données qui se trouvent à la case "Luc Doncieux" ». Pour retrouver l'âge et la moyenne de Luc Doncieux, on ne peut donc pas écrire : Code : C tableau["Luc Doncieux"];
134. Ce ["Luc Doncieux"] comme je l'ai fait précédemment. Ce n'est pas valide en C. La question est : comment transformer une chaîne de caractères en numéro ? C'est toute la magie du hachage. Il faut écrire une fonction qui prend en entrée une chaîne de caractères, fait des calculs avec, puis retourne en sortie un numéro correspondant à cette chaîne. Ce numéro sera l'indice de la case dans notre tableau (fig. suivante).
135. Si une collision survient, pas de panique ! Deux solutions s'offrent à vous au choix : l'adressage ouvert et le chaînage.

View morearrow_downward

Related papers

Programmez avec le langage C++ Par Mathieu Nebra (Mateo21) et Matthieu Schaller (Nanocmwafrika josuedownloadDownload free PDFView PDFchevron_right14189-apprenez-a-programmer-en-cre redownloadDownload free PDFView PDFchevron_rightApprenez à développer en Cmarkus nsonkoualdownloadDownload free PDFView PDFchevron_rightProgrammer en langage CSam BdownloadDownload free PDFView PDFchevron_rightProgrammer en langage C Avec exercices corrigésWiam Matat

Le langage C a été créé en 1972 par Denis Ritchie avec un objectif relativement limité : écrire un système d'exploitation (UNIX). Mais ses qualités "opérationnelles" l'ont très vite fait adopter par une large communauté de programmeurs.

downloadDownload free PDFView PDFchevron_right

• Explore
• Papers
• Topics

• Features
• Mentions
• Analytics
• PDF Packages
• Advanced Search
• Search Alerts

• Journals
• Academia.edu Journals
• My submissions
• Reviewer Hub
• Why publish with us
• Testimonials

• Company
• About
• Careers
• Press
• Help Center
• Terms
• Privacy
• Copyright
• Content Policy

580 California St., Suite 400San Francisco, CA, 94104© 2026 Academia. All rights reserved