Partage
  • Partager sur Facebook
  • Partager sur Twitter

[Concours] Après la console, place à la SDL

Éblouissez-nous !

Sujet résolu
    5 février 2011 à 19:33:00

    The first, la liberté...
    The second, la restriction...
    The third, La SDL !

    Puisqu'il n'y a pas eu de pseudo-vrai-concours-non-officiel depuis un petit bout de temps, je vous propose d'en créer un qui consiste à créer un programme utilisant la Image utilisateur !
    En effet, j'ai pu constater dans les deux concours lancés par camboui, que plusieurs zéros voulaient en avoir un concernant la SDL. Un concours SDL est très instructif, les membres de ce site l'ont bien compris.

    Changement de dernière minute !
    </h4>
    Vu qu'il y a beaucoup de zéros qui veulent ou qui ont besoins de plus de temps, je repousse la date limite d'un mois !
    Le jury ramassera donc les copie le mercredi 01/06/2011 à 23h59m59s.
    La deadline est changée...

    Les règles


    Ne vous inquiétez pas, il n'y a rien de méchant, je ne suis pas si diabolique que ça. :diable:
    • Thème : Vous devez créer un quelconque jeu ou programme utilisant la SDL
    • Contraintes :
      • Vous devez partir d'un fichier main.c vierge. Ne copiez pas le contenu d'autre fichier, gare aux tricheurs :pirate:
      • Vous devez poster votre programme (ou le lien de téléchargement de votre programme) sur ce topic. Je rajouterai votre nom ainsi que celui de votre projet dans la liste des participants
      • Vous ne pouvez poster qu'un seul programme par personne ou par groupe
      • Vous de devez pas demander de aide sur ce topic, si vous en avez besoin, créez un topic d'avancement de votre projet
    • Droits :
      • Vous avez le droit d'éditer à volonté votre programme jusqu'au deadline (dimanche 1er mai, 20h 00m 00s mercredi 01/06/2011 à 23h59m59s)
      • Vous avez le droit d'utiliser le langage C et le langage C++
      • Vous avez le droit d'utiliser SDL, SDL_Image, SDL_ttf, SDLP_Anim, SDL_Mixer, SDL_gfx et FMOD
      • Vous avez le droit de former un de groupe de trois personnes maximum
      • Vous avez évidemment le droit de créer un programme seul :lol:

    Conseil


    Pour que vous ayez le maximum de points, votre code devra compiler avec le minimum de warnings.
    Je vous conseille de lire ma bio, vous serez plus rigoureux.
    Si vous voulez débugger ou stabiliser votre programme SDL, la bio de SofEvans et celle de C159 sont faites pour vous (lien dans ma bio).
    Lorsque vous posterez votre projet, une petite description serait la bienvenue.


    Petites infos


    Je remercie tous les futurs participants et je les prie de bien respecter les règles, je vous fais confiance, pas de triche sinon... Image utilisateur !
    Tous les Zéros sont invités à ce concours, du moins ceux qui connaissent la SDL. :-°
    Cette expérience est avant tout une petite activité pour les gens du forum, mais elle aidera aussi à améliorer la connaissance et l'apprentissage de la programmation des participants grâce aux juges qui vous donneront les commentaires.


    N'oubliez pas

    • La date limite de la présentation de votre programme est le dimanche 1er mai, 20h 00m 00s mercredi 01/06/2011 à 23h59m59s .
    • votre projet ne doit contenir aucune erreur, alors pensez à corriger, améliorer optimiser votre programme afin d'être au top ! Tout code ne compilant pas chez un correcteur sera fortement pénalisé
    • Tout message réédité après la deadline sera disqualifié d'office

    Les participants actuels


    Le tableau ci-dessous, classé par date de participation, présente les projets et leurs créateurs.

    22 participants

    Créateur Programme Topic d'avancement du projet
    schadocalex Delthera (dèltéra) NULL
    Tixlegeek Matixlegeek Existant
    perimgui Tours de Hanoï Existant
    lucas-84 Zério, le Mario du Site du Zéro Existant
    Keriz Zpong Existant
    yoch démineur NULL
    sydzero Naval Battle Existant
    Odolwan Funky Drums NULL
    Til0u Casse-Briques Existant
    sercus i Ovarium NULL
    gobelin97 SURVIVAL NULL
    Pouet_forever Rubik's cube NULL
    paraze Linefactor Existant
    macmist SDLectronicKeyboard Existant
    LordOfWar Lord of War NULL
    shamanas SDFx Existant
    Ptitlue zTaquin Existant
    personne@ Bataille navale NULL
    nerem JetPack 2011 NULL
    sismic Naruto Sokoban Existant
    HomerEro Space Invaders Existant


    Anciens participants


    4 participants

    Créateur Programme Topic d'avancement du projet
    florent m Snake NULL
    Krypt PaintDémineur Existant
    darkipod PONG Existant
    tsunami33 Shaak NULL
    _Fender_ Bar's Ball Existant


    Le jury


    Ce seront eux qui vous donneront un grand commentaire, des conseils... et qui noteront vos projets.
    Le voici :
    • paraze
    • lucas-84
    • Gniarff
    • informaticienzero


    La notation


    Les notes seront données après le rendu (logique :soleil: ), les correcteurs auront le temps qu'ils souhaitent pour analyser et noter les codes (sûrement moins de 2 mois).
    Les jurés ont les mêmes critères de notations, ils noteront séparément chaque programme puis effectueront une moyenne.

    Critères de notations
    • /10 Le code source
      • /2 Compilation
        • /1 Code portable
        • /1 le code source compile avec moins de 2 warnings, au moins avec :
          • Code::Blocks : -Wall -pedantic -Wextra.
          • Microsoft Visual C++ : niveau (level) de warning à 4.
      • /2.5 Structure du code
        • /1 Le code est concis, facilement lisible, indenté.
        • /1 Les noms de variables et de fonctions sont représentatifs.
        • /0.5 Les commentaires présents sont utiles et aident à la compréhension.
      • /1.5 Gestion de la mémoire
        • /1 la mémoire est correctement gérée.
        • /0.5 L'accession aux cases des tableaux est correcte.
      • /4 Conception
        • /1 Découpage en fichiers.
        • /1.5 Découpage en fonctions
        • /1.5 L'utilisation des variables globales est minime. Dans certains cas, elle est acceptée.
    • /10 L'aspect visuel / le rendu
    SI le projet est un jeu : /3 Gameplay</li> /3 Graphismes</li> /4 Général
    • /1 Facile à prendre en main.
    • /1 Durée de vie (ne pas finir le jeu en 30 secondes...).
    • /2 Originalité.
    </li> </ul>SI le projet est un programme : /4 Graphismes</li> /6 Général
    • /2 Facile à prendre en main.
    • /1 Durée de vie (ne pas finir le programme en 30 secondes...).
    • /3 Originalité.
    </li> </ul>+++ Bonus /1.5 Bonus +++
    • /0.5 Algorithmes et structures de données astucieuses et adaptées aux problèmes.
    • /0.5 Le code compile sans warning avec les options de compilations recommandées présentés dans ma bio
    • /0.5 le programme est une invention
    </li> </ul>

    Voici la démarche à suivre pour configurer Code::Blocks : Project => Build options => clique en haut à gauche sur le nom de ton projet => onglet "Compiler settings" => sous-onglet "Other options".
    Ensuite, vous pouvez ajouter les options de compilation souhaitées.
    Enfin, faites "Régénérer" (Ctrl + F11).

    Voici la démarche à suivre pour configurer Microsoft Visual C++ : Propriétés du projet => C/C++ => général.
    Ensuite, vous pouvez mettre le niveau (level) de warning à 4.


    historique :



    05/02/2011 : Création du topique
    06/02/2011 : Mise en place du barème
    06/02/2011 : Ajout de paraze (en gros, moi) comme juré. Mise en place des critères de notation.
    06/02/2011 : Changement de la deadline, le dimanche 1er mai, 20h 00m 00s (c'est à dire le jour de la fête du travail).
    06/02/2011 : Précision des droits et des interdits.
    06/02/2011 : Ajout de GurneyH comme juré. Mise en place des bibliothèques qu'on a le droit d'utiliser.
    06/02/2011 : Ajout de ce que GurneyH notera.
    07/02/2011 : Suppression d'une contrainte qui était en contradiction avec un droit.
    07/02/2011 : Ajout d'une sorte de groupe.
    09/02/2011 : Ajout dans "Critères de notation de paraze".
    09/02/2011 : Ajout de lucas-84 comme juré. énorme ajout dans "Les notes". Énorme mise à jour dans "Les notes".
    09/02/2011 : Mini rajout dans "Les notes".
    10/02/2011 : Petites modifications dans "Critères de notation de paraze".
    11/02/2011 : Suppression de GurneyH comme juré. Petit changement dans "Critères de notation de paraze".
    11/02/2011 : Ajout de Gniarff comme juré.
    13/02/2011 : Bonne mise à jour de "Les notes".
    15/02/2011 : Grosse correction orthographique.
    15/02/2011 : Changement de "Les notes" en "La notation".
    15/02/2011 : Changement de la liste des participants en tableau. Rajout de lien vers le nom du créateur du programme.
    15/02/2011 : Ajout d'une petite description du tableau des participants.
    15/02/2011 : Changement de place des remerciements.
    15/02/2011 : Les dates de l'historique sont en italique et souligné. Correction orthographique mineur.
    15/02/2011 : Petite mise à jour de l'introduction.
    15/02/2011 : Mise en place de multiples optimisations grammaticales.
    15/02/2011 : Suppression des sortes de groupe prédéfinit, désormais, un groupe est simplement formé de trois personnes maximum (suite à une remarque de schadocalex).
    16/02/2011 : Changement de "créez en un autre" en "créez un topic d'avancement de votre projet" dans "Les règles".
    16/02/2011 : Ajout des instructions pour configurer son compilateur (suite à une remarque de Kyron).
    19/02/2011 : Ajout des instructions pour configurer Microsoft Visual C++. Changement de place des démarches à suivre pour configurer son compilateur. Petite modification dans les règles concernant la configuration des compilateurs.
    21/02/2011 : Modifications des critères de notations (prise en charge des programme) suite à une remarque de programLyrique. Ajout de "Critères de notations" dans la balise secret des critères de notations.
    23/04/2011 : Changement de la deadline, les participants devront rendre leur programme au maximum le mercredi 01/06/2011 à 23h59m59s.
    26/04/2011 : Ajout de la sous-catégorie "Le jury". Ajout de informaticienzero comme juré.
    28/04/2011 : Changement des options de compilations de code::blocks.
    30/04/2011 : Correction orthographique mineure.


    Merci d'avance && bonne chance !
    • Partager sur Facebook
    • Partager sur Twitter
      6 février 2011 à 0:29:45

      sympa comme concours ... dommage que je n'ai pas le temps :(
      • Partager sur Facebook
      • Partager sur Twitter
        6 février 2011 à 0:33:34

        Dans le fond l'idée n'est pas mauvaise.

        Mais, la SDL c'est large...

        M'enfin ça peut être l'occasion de voir des choses jolies en sdl.

        Mais je doute vraiment, voir le dernier concours de camboui, on a été 2(a pas avoir piscine) ;)
        • Partager sur Facebook
        • Partager sur Twitter
        Zeste de Savoir, le site qui en a dans le citron !
          6 février 2011 à 8:54:10

          Merci de vos réponses.

          En fait, j'ai hésité de mettre un thème précis, et camboui m'a conseillé de faire un sujet libre pour voir de tout. :)
          Je tiens à précisé qu'il y avait 3 participants, le dernier n'avait pas basket... Et qui ne tente rien n'a rien !

          Néanmoins, je fais ce concours environ 4 mois avant le Bac (contrairement au précédant qui était justement pendant cette période), j'espère donc un peu plus de participant. :D
          • Partager sur Facebook
          • Partager sur Twitter
            6 février 2011 à 9:07:26

            On est obligé de le faire en C ? Ou C++ est autorisé ?
            • Partager sur Facebook
            • Partager sur Twitter
              6 février 2011 à 9:11:37

              Pas mal comme idée, mais je ne pense pas que je le ferai parce que j'ai pas le temps, il faut que je termine mon tuto mais je pense faire un puissance 4 si j'ai le temps, sinon donne un barême stp

              Citation : Keriz

              On est obligé de le faire en C ? Ou C++ est autorisé ?


              comme tu veux je pense
              • Partager sur Facebook
              • Partager sur Twitter
                6 février 2011 à 9:28:00

                Merci C159. ;)

                @Keriz : Contrairement aux 2 autres, le C++ est accepté; mais préférez tout de même le C, on est sur le forum C.
                • Partager sur Facebook
                • Partager sur Twitter
                  6 février 2011 à 9:49:35

                  Je doute également, surtout avec un délai aussi court.
                  • Partager sur Facebook
                  • Partager sur Twitter
                  "If debbugging is the process of removing bugs, then programming must be the process of putting them in." (Edsger Dijkstra)
                    6 février 2011 à 9:53:28

                    2 mois, ce n'est pas assez ?

                    Je peux retarder la fin concours si nécessaire.
                    • Partager sur Facebook
                    • Partager sur Twitter
                      6 février 2011 à 10:09:48

                      Désolé, j'avais mal lu.
                      • Partager sur Facebook
                      • Partager sur Twitter
                      "If debbugging is the process of removing bugs, then programming must be the process of putting them in." (Edsger Dijkstra)
                        6 février 2011 à 10:25:20

                        Je pourrais éventuellement, si j'en ai le temps, participer.Faut voir, mais c'est vrai que 2 mois c'est court...
                        • Partager sur Facebook
                        • Partager sur Twitter
                          6 février 2011 à 10:48:34

                          Oui je n'aurais pour ma part en deux mois pas le temps (mais 2 mois et demie ou 3 mois serais bien ...)
                          • Partager sur Facebook
                          • Partager sur Twitter
                            6 février 2011 à 11:06:06

                            Voilà les changements :
                            • Mise en place du barème
                            • Ajout de paraze (en gros, moi :honte: ) comme juré. Mise en place des critères de notation.
                            • Changement de la deadline, le dimanche 1er mai, 20h 00m 00s (c'est à dire le jour de la fête du travail).

                            Quand pensez vous ?
                            Désormais, qui compte participer ?
                            • Partager sur Facebook
                            • Partager sur Twitter
                              6 février 2011 à 11:52:08

                              Moi je compte participer, très bien comme ça.
                              • Partager sur Facebook
                              • Partager sur Twitter
                              "If debbugging is the process of removing bugs, then programming must be the process of putting them in." (Edsger Dijkstra)
                                6 février 2011 à 12:59:00

                                Bonjour je voudrais participer et présenté un jeu que j'ai déjà fait mais enfaîte il reprend des commande de Sokoban mais j'ai écrit les commande pas copier est ce que çà irait ?
                                • Partager sur Facebook
                                • Partager sur Twitter
                                  6 février 2011 à 13:01:56

                                  Tu peux, mais tu dois recommencer tout le programme. ;)
                                  • Partager sur Facebook
                                  • Partager sur Twitter
                                    6 février 2011 à 13:14:05

                                    Mais je comprend pas pourquoi je devrait retaper les même lignes lol pourquoi faire çà ? çà va me prendre es heures pour rien.

                                    Alors pourquoi faire çà ?
                                    • Partager sur Facebook
                                    • Partager sur Twitter
                                      6 février 2011 à 13:18:28

                                      je m'inscrit,mais je suis pas un expert en sdl.......,
                                      (je trebuche depuis deux mois sur le tuto de fvirtman (qui est bien fait) sur la simplification des events, et je veux pas poursuivre plus loin tant que j'ai pas assimilé)
                                      :p
                                      mon projet : peut etre un pong
                                      • Partager sur Facebook
                                      • Partager sur Twitter
                                        6 février 2011 à 13:21:32

                                        parce que c'est le but du concours tout faire à partir de son départ

                                        EDIT je commence le puissance 4
                                        • Partager sur Facebook
                                        • Partager sur Twitter
                                          6 février 2011 à 13:25:25

                                          Ok ba je vais peut être crée un nouveau jeu en tous cas j'essayerais de participer.
                                          • Partager sur Facebook
                                          • Partager sur Twitter
                                            6 février 2011 à 13:35:00

                                            Je vais m'inscrire aussi, car j'ai jamais fait de bons projets en SDL.
                                            Je pense faire un snake
                                            • Partager sur Facebook
                                            • Partager sur Twitter
                                              6 février 2011 à 14:54:19

                                              Une question, peut on poster un programme avec OpenGL(j'utilise la SDL pour le fenêtrage et la gestion des évènements :p )?
                                              • Partager sur Facebook
                                              • Partager sur Twitter
                                                6 février 2011 à 15:20:42

                                                Delthera (prononciation : dèltéra)


                                                Le gameplay et le scénario sont innovants, bien qu'ambitieux pour le temps que je peux y consacrer seul. Ce projet a été réfléchi pendant plus d'un an, il est passé de MMORPG à A-RPG pour dzevenir un jeu de plate-forme, beaucoup moins ambitieux. Ce n'est pas un jeu initialement conçu pour ce concours, une petite recherche sur le sdz vous le comfirmera. Néanmoins, j'ai repris de zéro le code pour ce concours, car je me suis améliorer depuis le temps, et bien qu'il soit très loin d'être fini, je compte le finir tôt ou tard.
                                                Si un ou plusieurs programmeurs C quelque peu compétents souhaitent m'épauler, contactez moi par MP, afin de m'aider à finir ce projet. :D

                                                Build 2


                                                <object width="480" height="360" type="application/x-shockwave-flash" data="http://www.youtube.com/v/DRmDL3e8pUw"><param name="movie" value="http://www.youtube.com/v/DRmDL3e8pUw" /><param name="allowFullScreen" value="true" /><param name="wmode" value="transparent" /></object>

                                                Nota :
                                                • Le titre de la fenêtre est "Delthera - build 1" mais c'est bien la build 2.
                                                • La gravité est un peu faible.
                                                • Le personnage va plus ou moins vite en fonction du degré de la montée, ça ne lag pas. Ceci est dû à ma gestion des collisions au pixel près, cf player.c si vous comprenez.

                                                Télécharger le dossier complet du jeu. (450Ko)

                                                Code source


                                                main.c
                                                /*
                                                     ____      _____    _       _____    _   _    _____    _____     _____
                                                    |  __ \   |  ___|  | |     |_   _|  | | | |  |  ___|  |  _  |   |  _  |
                                                    | |  | |  | |_     | |       | |    | |_| |  | |_     | |_| |   | |_| |
                                                    | |  | |  |  _|    | |       | |    |  _  |  |  _|    |  _  /   |  _  |
                                                    | |__| |  | |___   | |___    | |    | | | |  | |___   | | \ \   | | | |
                                                    |____ /   |_____|  |_____|   |_|    |_| |_|  |_____|  |_|  \_\  |_| |_|
                                                
                                                    name     : main.c
                                                    function : Fonction main
                                                    author   : schadocalex
                                                
                                                */
                                                
                                                #include "main.h"
                                                #include "MySDL.h"
                                                #include "map.h"
                                                #include "game.h"
                                                
                                                int main(int argc, char** argv)
                                                {
                                                    /* Pour enlever les deux warnings */
                                                    if(argc || argv){}
                                                
                                                    return game();
                                                }
                                                

                                                main.h
                                                /*
                                                     ____      _____    _       _____    _   _    _____    _____     _____
                                                    |  __ \   |  ___|  | |     |_   _|  | | | |  |  ___|  |  _  |   |  _  |
                                                    | |  | |  | |_     | |       | |    | |_| |  | |_     | |_| |   | |_| |
                                                    | |  | |  |  _|    | |       | |    |  _  |  |  _|    |  _  /   |  _  |
                                                    | |__| |  | |___   | |___    | |    | | | |  | |___   | | \ \   | | | |
                                                    |____ /   |_____|  |_____|   |_|    |_| |_|  |_____|  |_|  \_\  |_| |_|
                                                
                                                    name     : main.h
                                                    function : Inclusions principales (bibliotèque standard + SDL) et #define pour la SDL
                                                    author   : schadocalex
                                                
                                                */
                                                
                                                #ifndef MAIN_H_INCLUDED
                                                #define MAIN_H_INCLUDED
                                                
                                                #include <stdio.h>
                                                #include <SDL/SDL.h>
                                                
                                                /* Nécéssaire à la modification des pixels */
                                                #if SDL_BYTEORDER == SDL_BIG_ENDIAN
                                                    #define MASQUE_ROUGE 0xff000000
                                                    #define MASQUE_VERT  0x00ff0000
                                                    #define MASQUE_BLEU  0x0000ff00
                                                    #define MASQUE_ALPHA 0x000000ff
                                                #else
                                                    #define MASQUE_ROUGE 0x000000ff
                                                    #define MASQUE_VERT  0x0000ff00
                                                    #define MASQUE_BLEU  0x00ff0000
                                                    #define MASQUE_ALPHA 0xff000000
                                                #endif
                                                
                                                #endif /* MAIN_H_INCLUDED */
                                                

                                                map.c
                                                /*
                                                     ____      _____    _       _____    _   _    _____    _____     _____
                                                    |  __ \   |  ___|  | |     |_   _|  | | | |  |  ___|  |  _  |   |  _  |
                                                    | |  | |  | |_     | |       | |    | |_| |  | |_     | |_| |   | |_| |
                                                    | |  | |  |  _|    | |       | |    |  _  |  |  _|    |  _  /   |  _  |
                                                    | |__| |  | |___   | |___    | |    | | | |  | |___   | | \ \   | | | |
                                                    |____ /   |_____|  |_____|   |_|    |_| |_|  |_____|  |_|  \_\  |_| |_|
                                                
                                                    name     : map.c
                                                    function : Fonction de chargement, initialisation et libération de mémoire de la map
                                                    author   : schadocalex
                                                
                                                */
                                                
                                                #include "map.h"
                                                #include "MySDL.h"
                                                
                                                /* Calcule le nombre de lignes du curseur jusqu'au caractère stop_c
                                                   sans affecter la position du curseur */
                                                int numberLines(const char stop_c, FILE* f)
                                                {
                                                    long actualPosition = ftell(f);
                                                    char c;
                                                    int i = 0;
                                                
                                                    do
                                                    {
                                                        c = fgetc(f);
                                                        if(c == '\n')
                                                            i++;
                                                    } while(c != stop_c && c != EOF);
                                                    fseek(f, actualPosition, SEEK_SET);
                                                
                                                    return i;
                                                }
                                                
                                                int loadMapFloor(Map *map, FILE* f)
                                                {
                                                    int i;
                                                
                                                    map->nomberCaseFloor = numberLines(EOF, f);
                                                
                                                    if(!(map->floor = malloc(map->nomberCaseFloor * sizeof(Case))))
                                                        return 1;
                                                
                                                    for(i = 0; i < map->nomberCaseFloor; i++)
                                                    {
                                                        fscanf(f, "%hu %hu %hu %hu\n", &map->floor[i].position.x, &map->floor[i].position.y, &map->floor[i].chipset.x, &map->floor[i].chipset.y);
                                                        map->floor[i].position.x *= 32;
                                                        map->floor[i].position.y *= 32;
                                                
                                                        map->floor[i].chipset.x *= 32;
                                                        map->floor[i].chipset.y *= 32;
                                                        map->floor[i].chipset.w = 32;
                                                        map->floor[i].chipset.h = 32;
                                                    }
                                                
                                                    return 0;
                                                }
                                                
                                                /* Charge la map dans la structure map */
                                                int loadMap(Map *map, const char* url)
                                                {
                                                    /* Initialisations */
                                                    FILE* f = NULL;
                                                    if(!(f = fopen(url, "r")))
                                                    {
                                                        fprintf(stderr, "Impossible de charger la map %s", url);
                                                        return 1;
                                                    }
                                                
                                                    /* Récupération de la largeur et de la hauteur */
                                                    fscanf(f, "%d %d\n\n", &map->w, &map->h);
                                                
                                                    /* Chargement de la map */
                                                    if(loadMapFloor(map, f))
                                                        return 1;
                                                
                                                    fprintf(stdout, "Chargement de la map réussi.\n");
                                                
                                                    return 0;
                                                }
                                                
                                                /* Charge la map dans la structure map */
                                                void loadMapChipset(Map *map, const char* url, const char* url_masque)
                                                {
                                                    map->chipset = loadImage(url);
                                                    map->chipset_masque = loadImage(url_masque);
                                                }
                                                
                                                int initialiseMap(Map *map, int nb_map)
                                                {
                                                    if(nb_map == 1)
                                                    {
                                                        if(loadMap(map, "map/1.map"))
                                                            return 1;
                                                        loadMapChipset(map, "img/grass.png", "img/grass_masque.png");
                                                    }
                                                    return 0;
                                                }
                                                
                                                void freeMap(Map *map)
                                                {
                                                    free(map->floor);
                                                }
                                                

                                                map.h
                                                /*
                                                     ____      _____    _       _____    _   _    _____    _____     _____
                                                    |  __ \   |  ___|  | |     |_   _|  | | | |  |  ___|  |  _  |   |  _  |
                                                    | |  | |  | |_     | |       | |    | |_| |  | |_     | |_| |   | |_| |
                                                    | |  | |  |  _|    | |       | |    |  _  |  |  _|    |  _  /   |  _  |
                                                    | |__| |  | |___   | |___    | |    | | | |  | |___   | | \ \   | | | |
                                                    |____ /   |_____|  |_____|   |_|    |_| |_|  |_____|  |_|  \_\  |_| |_|
                                                
                                                    name     : map.h
                                                    function : Structures (Case, Map) et prototypes des fonctions de map.c
                                                    author   : schadocalex
                                                
                                                */
                                                
                                                #ifndef MAP_H_INCLUDED
                                                #define MAP_H_INCLUDED
                                                
                                                #include "main.h"
                                                
                                                typedef struct
                                                {
                                                    SDL_Rect chipset;
                                                    SDL_Rect position;
                                                } Case;
                                                
                                                typedef struct
                                                {
                                                    SDL_Surface* chipset;
                                                    SDL_Surface* chipset_masque;
                                                
                                                    int w;
                                                    int h;
                                                    int nomberCaseFloor;
                                                
                                                    Case* floor;
                                                    Case* PF;
                                                } Map;
                                                
                                                int numberLines(const char stop_c, FILE* f);
                                                int loadMapFloor(Map *map, FILE* f);
                                                int loadMap(Map *map, const char* url);
                                                void loadMapChipset(Map *map, const char* url, const char* url_masque);
                                                int initialiseMap(Map *map, int nb_map);
                                                void freeMap(Map *map);
                                                
                                                #endif /* MAP_H_INCLUDED */
                                                

                                                events.c
                                                /*
                                                     ____      _____    _       _____    _   _    _____    _____     _____
                                                    |  __ \   |  ___|  | |     |_   _|  | | | |  |  ___|  |  _  |   |  _  |
                                                    | |  | |  | |_     | |       | |    | |_| |  | |_     | |_| |   | |_| |
                                                    | |  | |  |  _|    | |       | |    |  _  |  |  _|    |  _  /   |  _  |
                                                    | |__| |  | |___   | |___    | |    | | | |  | |___   | | \ \   | | | |
                                                    |____ /   |_____|  |_____|   |_|    |_| |_|  |_____|  |_|  \_\  |_| |_|
                                                
                                                    name     : events.c
                                                    function : Gestion des events propre
                                                    author   : schadocalex (remerciements à Fvirtman pour son tutoriel)
                                                
                                                */
                                                
                                                #include "main.h"
                                                #include "events.h"
                                                
                                                /* Mis à jour des events
                                                   Enregistrement du moment ou l'on a appuyé sur une touche,
                                                   Pour une meilleure gestion des events */
                                                void UpdateEvents(Input* in)
                                                {
                                                	SDL_Event event;
                                                	while(SDL_PollEvent(&event))
                                                	{
                                                		switch (event.type)
                                                		{
                                                            case SDL_KEYDOWN:
                                                                if(in->key[event.key.keysym.sym] == 0)
                                                                    in->key[event.key.keysym.sym] = SDL_GetTicks();
                                                            break;
                                                            case SDL_KEYUP:
                                                                in->key[event.key.keysym.sym] = 0;
                                                            break;
                                                            case SDL_QUIT:
                                                                in->quit = 1;
                                                            break;
                                                            default: break;
                                                		}
                                                	}
                                                }
                                                

                                                events.h
                                                /*
                                                     ____      _____    _       _____    _   _    _____    _____     _____
                                                    |  __ \   |  ___|  | |     |_   _|  | | | |  |  ___|  |  _  |   |  _  |
                                                    | |  | |  | |_     | |       | |    | |_| |  | |_     | |_| |   | |_| |
                                                    | |  | |  |  _|    | |       | |    |  _  |  |  _|    |  _  /   |  _  |
                                                    | |__| |  | |___   | |___    | |    | | | |  | |___   | | \ \   | | | |
                                                    |____ /   |_____|  |_____|   |_|    |_| |_|  |_____|  |_|  \_\  |_| |_|
                                                
                                                    name     : events.h
                                                    function : Structure (Input) et prototype de events.c
                                                    author   : schadocalex (remerciements à Fvirtman pour son tutoriel)
                                                
                                                */
                                                
                                                #ifndef EVENTS_H_INCLUDED
                                                #define EVENTS_H_INCLUDED
                                                
                                                typedef struct
                                                {
                                                	int key[SDLK_LAST];
                                                    char quit;
                                                } Input;
                                                
                                                void UpdateEvents(Input* in);
                                                
                                                #endif /* EVENTS_H_INCLUDED */
                                                

                                                pixel.c
                                                /*
                                                     ____      _____    _       _____    _   _    _____    _____     _____
                                                    |  __ \   |  ___|  | |     |_   _|  | | | |  |  ___|  |  _  |   |  _  |
                                                    | |  | |  | |_     | |       | |    | |_| |  | |_     | |_| |   | |_| |
                                                    | |  | |  |  _|    | |       | |    |  _  |  |  _|    |  _  /   |  _  |
                                                    | |__| |  | |___   | |___    | |    | | | |  | |___   | | \ \   | | | |
                                                    |____ /   |_____|  |_____|   |_|    |_| |_|  |_____|  |_|  \_\  |_| |_|
                                                
                                                    name     : pixel.c
                                                    function : Fonctions d'écriture et de lecture de pixels
                                                    author   : schadocalex (remerciements à Piwaï pour son tutoriel)
                                                
                                                */
                                                
                                                #include "main.h"
                                                #include "pixel.h"
                                                
                                                Uint32 getPixel(SDL_Surface* surface, int x, int y)
                                                {
                                                    int BytesPerPixel = surface->format->BytesPerPixel;
                                                    Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * BytesPerPixel;
                                                
                                                    switch(BytesPerPixel)
                                                    {
                                                        case 1:
                                                            return *p;
                                                        case 2:
                                                            return *(Uint16 *)p;
                                                        case 3:
                                                            if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
                                                                return p[0] << 16 | p[1] << 8 | p[2];
                                                            else
                                                                return p[0] | p[1] << 8 | p[2] << 16;
                                                        case 4:
                                                            return *(Uint32 *)p;
                                                        default:
                                                            return 0;
                                                    }
                                                }
                                                
                                                void setPixel(Uint32 pixel, SDL_Surface *surface, int x, int y)
                                                {
                                                    int BytesPerPixel = surface->format->BytesPerPixel;
                                                    Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * BytesPerPixel;
                                                
                                                    switch(BytesPerPixel)
                                                    {
                                                        case 1:
                                                            *p = pixel;
                                                        break;
                                                        case 2:
                                                            *(Uint16 *)p = pixel;
                                                        break;
                                                        case 3:
                                                            if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
                                                            {
                                                                p[0] = (pixel >> 16) & 0xff;
                                                                p[1] = (pixel >> 8) & 0xff;
                                                                p[2] = pixel & 0xff;
                                                            }
                                                            else
                                                            {
                                                                p[0] = pixel & 0xff;
                                                                p[1] = (pixel >> 8) & 0xff;
                                                                p[2] = (pixel >> 16) & 0xff;
                                                            }
                                                        break;
                                                        case 4:
                                                            *(Uint32 *)p = pixel;
                                                        break;
                                                    }
                                                }
                                                

                                                pixel.h
                                                /*
                                                     ____      _____    _       _____    _   _    _____    _____     _____
                                                    |  __ \   |  ___|  | |     |_   _|  | | | |  |  ___|  |  _  |   |  _  |
                                                    | |  | |  | |_     | |       | |    | |_| |  | |_     | |_| |   | |_| |
                                                    | |  | |  |  _|    | |       | |    |  _  |  |  _|    |  _  /   |  _  |
                                                    | |__| |  | |___   | |___    | |    | | | |  | |___   | | \ \   | | | |
                                                    |____ /   |_____|  |_____|   |_|    |_| |_|  |_____|  |_|  \_\  |_| |_|
                                                
                                                    name     : pixel.h
                                                    function : Structure (Pixel) et prototypes de pixel.c
                                                    author   : schadocalex (remerciements à Piwaï pour son tutoriel)
                                                
                                                */
                                                
                                                #ifndef PIXEL_H_INCLUDED
                                                #define PIXEL_H_INCLUDED
                                                
                                                typedef struct
                                                {
                                                    Uint8 r;
                                                    Uint8 g;
                                                    Uint8 b;
                                                    Uint8 a;
                                                } Pixel;
                                                
                                                Uint32 getPixel(SDL_Surface* surface, int x, int y);
                                                void setPixel(Uint32 pixel, SDL_Surface *surface, int x, int y);
                                                
                                                #endif /* PIXEL_H_INCLUDED */
                                                

                                                MySDL.c
                                                /*
                                                     ____      _____    _       _____    _   _    _____    _____     _____
                                                    |  __ \   |  ___|  | |     |_   _|  | | | |  |  ___|  |  _  |   |  _  |
                                                    | |  | |  | |_     | |       | |    | |_| |  | |_     | |_| |   | |_| |
                                                    | |  | |  |  _|    | |       | |    |  _  |  |  _|    |  _  /   |  _  |
                                                    | |__| |  | |___   | |___    | |    | | | |  | |___   | | \ \   | | | |
                                                    |____ /   |_____|  |_____|   |_|    |_| |_|  |_____|  |_|  \_\  |_| |_|
                                                
                                                    name     : MySDL.c
                                                    function : Extension de la SDL
                                                    author   : schadocalex
                                                
                                                */
                                                
                                                #include <SDL/SDL_Image.h>
                                                
                                                #include "main.h"
                                                #include "MySDL.h"
                                                
                                                /* Charge une image */
                                                SDL_Surface* loadImage(const char* url)
                                                {
                                                    SDL_Surface* img = IMG_Load(url);
                                                    if(!img)
                                                    {
                                                        fprintf(stderr, "Impossible d'ouvrir %s\n", url);
                                                        exit(EXIT_FAILURE);
                                                    }
                                                    else
                                                        fprintf(stdout, "Chargement de %s\n", url);
                                                    return img;
                                                }
                                                
                                                /* Initialise la SDL et la fenêtre */
                                                SDL_Surface* MySDL_Init(int largeur, int hauteur)
                                                {
                                                    /* Initialisation de la SDL */
                                                    if(SDL_Init(SDL_INIT_VIDEO) < 0)
                                                    {
                                                        fprintf(stderr, "Impossible d'initialiser la SDL : %s\n", SDL_GetError());
                                                        exit(EXIT_FAILURE);
                                                    }
                                                    else
                                                        fprintf(stdout, "Initialisation de la SDL\n");
                                                
                                                    /* On ferme la SDL à la fin du programme */
                                                    atexit(SDL_Quit);
                                                
                                                    /* Création de la fenêtre */
                                                    SDL_Surface* screen = SDL_SetVideoMode(largeur, hauteur, 32,
                                                                                           SDL_SWSURFACE | SDL_DOUBLEBUF);
                                                    if(!screen)
                                                    {
                                                        fprintf(stderr, "Impossible de créer une fenêtre de %dx%d : %s\n", largeur, hauteur, SDL_GetError());
                                                        exit(EXIT_FAILURE);
                                                    }
                                                    else
                                                        fprintf(stdout, "Création de la fenêtre\n");
                                                    SDL_WM_SetCaption("Delthera - build 1", NULL);
                                                
                                                    return screen;
                                                }
                                                

                                                MySDL.h
                                                /*
                                                     ____      _____    _       _____    _   _    _____    _____     _____
                                                    |  __ \   |  ___|  | |     |_   _|  | | | |  |  ___|  |  _  |   |  _  |
                                                    | |  | |  | |_     | |       | |    | |_| |  | |_     | |_| |   | |_| |
                                                    | |  | |  |  _|    | |       | |    |  _  |  |  _|    |  _  /   |  _  |
                                                    | |__| |  | |___   | |___    | |    | | | |  | |___   | | \ \   | | | |
                                                    |____ /   |_____|  |_____|   |_|    |_| |_|  |_____|  |_|  \_\  |_| |_|
                                                
                                                    name     : MySDL.h
                                                    function : Prototype de MySDL.c
                                                    author   : schadocalex
                                                
                                                */
                                                
                                                #ifndef MYSDL_H_INCLUDED
                                                #define MYSDL_H_INCLUDED
                                                
                                                SDL_Surface* loadImage(const char* url);
                                                SDL_Surface* MySDL_Init(int largeur, int hauteur);
                                                
                                                #endif /* MYSDL_H_INCLUDED */
                                                

                                                game.c (provisoire)
                                                /*
                                                     ____      _____    _       _____    _   _    _____    _____     _____
                                                    |  __ \   |  ___|  | |     |_   _|  | | | |  |  ___|  |  _  |   |  _  |
                                                    | |  | |  | |_     | |       | |    | |_| |  | |_     | |_| |   | |_| |
                                                    | |  | |  |  _|    | |       | |    |  _  |  |  _|    |  _  /   |  _  |
                                                    | |__| |  | |___   | |___    | |    | | | |  | |___   | | \ \   | | | |
                                                    |____ /   |_____|  |_____|   |_|    |_| |_|  |_____|  |_|  \_\  |_| |_|
                                                
                                                    name     : game.c
                                                    function : Fonction game qui sert de boucle principale du jeu
                                                    author   : schadocalex
                                                
                                                */
                                                
                                                #include "main.h"
                                                #include "map.h"
                                                #include "game.h"
                                                #include "MySDL.h"
                                                #include "player.h"
                                                #include "events.h"
                                                
                                                int game()
                                                {
                                                    Map map;
                                                    Player player;
                                                    SDL_Surface *screen, *screenMasque;
                                                    char continuer = 1;
                                                    int i;
                                                
                                                    if(initialiseMap(&map, 1))
                                                        return 1;
                                                
                                                    /* screen */
                                                    if((screen = MySDL_Init(map.w * 32, map.h * 32)) == NULL)
                                                        return 1;
                                                    SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 255, 255, 255));
                                                
                                                    /* screen masque */
                                                    screenMasque = SDL_CreateRGBSurface(SDL_HWSURFACE, map.w * 32, map.h * 32, 32, 0, 0, 0, 0);
                                                    SDL_FillRect(screenMasque, NULL, SDL_MapRGB(screen->format, 255, 255, 255));
                                                
                                                    /* décor */
                                                    for(i = 0; i < map.nomberCaseFloor; i++)
                                                    {
                                                        SDL_BlitSurface(map.chipset, &map.floor[i].chipset, screen, &map.floor[i].position);
                                                        SDL_BlitSurface(map.chipset_masque, &map.floor[i].chipset, screenMasque, &map.floor[i].position);
                                                    }
                                                
                                                    player_initialise(&player, "img/player.png");
                                                
                                                    SDL_Rect temp;
                                                
                                                    Input in;
                                                    memset(&in,0, sizeof(in));
                                                
                                                    while(continuer)
                                                    {
                                                        UpdateEvents(&in);
                                                
                                                        if(in.quit || in.key[SDLK_ESCAPE])
                                                            continuer = 0;
                                                
                                                        temp.x = player.position.x;
                                                        temp.y = player.position.y + 2;
                                                        temp.w = player.player_act.w;
                                                        temp.h = player.player_act.h;
                                                
                                                        if(in.key[SDLK_LEFT] > in.key[SDLK_RIGHT])
                                                            player.v_x = -4;
                                                        else if(in.key[SDLK_RIGHT])
                                                            player.v_x = 4;
                                                        else
                                                            player.v_x = 0;
                                                
                                                        if(in.key[SDLK_UP] && collision(screenMasque, temp))
                                                        {
                                                            if(player.v_s <= 0)
                                                                player.v_s = 6;
                                                        }
                                                
                                                        player_animation(&player, 60, screenMasque);
                                                        player_move(&player, screenMasque);
                                                
                                                        SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 255, 255, 255));
                                                        for(i = 0; i < map.nomberCaseFloor; i++)
                                                        {
                                                            SDL_BlitSurface(map.chipset, &map.floor[i].chipset, screen, &map.floor[i].position);
                                                            SDL_BlitSurface(map.chipset_masque, &map.floor[i].chipset, screenMasque, &map.floor[i].position);
                                                        }
                                                
                                                        SDL_BlitSurface(player.charset, &player.player_act, screen, &player.position);
                                                
                                                        SDL_Delay(40);
                                                
                                                        SDL_Flip(screen);
                                                    }
                                                
                                                    freeMap(&map);
                                                    SDL_free(screenMasque);
                                                
                                                    return 0;
                                                }
                                                

                                                game.h
                                                /*
                                                     ____      _____    _       _____    _   _    _____    _____     _____
                                                    |  __ \   |  ___|  | |     |_   _|  | | | |  |  ___|  |  _  |   |  _  |
                                                    | |  | |  | |_     | |       | |    | |_| |  | |_     | |_| |   | |_| |
                                                    | |  | |  |  _|    | |       | |    |  _  |  |  _|    |  _  /   |  _  |
                                                    | |__| |  | |___   | |___    | |    | | | |  | |___   | | \ \   | | | |
                                                    |____ /   |_____|  |_____|   |_|    |_| |_|  |_____|  |_|  \_\  |_| |_|
                                                
                                                    name     : game.h
                                                    function : Prototype des fonctions de game.c
                                                    author   : schadocalex
                                                
                                                */
                                                
                                                #ifndef GAME_H_INCLUDED
                                                #define GAME_H_INCLUDED
                                                
                                                int game(void);
                                                
                                                #endif /* GAME_H_INCLUDED */
                                                

                                                player.c
                                                /*
                                                     ____      _____    _       _____    _   _    _____    _____     _____
                                                    |  __ \   |  ___|  | |     |_   _|  | | | |  |  ___|  |  _  |   |  _  |
                                                    | |  | |  | |_     | |       | |    | |_| |  | |_     | |_| |   | |_| |
                                                    | |  | |  |  _|    | |       | |    |  _  |  |  _|    |  _  /   |  _  |
                                                    | |__| |  | |___   | |___    | |    | | | |  | |___   | | \ \   | | | |
                                                    |____ /   |_____|  |_____|   |_|    |_| |_|  |_____|  |_|  \_\  |_| |_|
                                                
                                                    name     : player.c
                                                    function : Fonctions relatives au joueur (initialisation, déplacements, animation etc.)
                                                    author   : schadocalex
                                                
                                                */
                                                
                                                #include "main.h"
                                                #include "player.h"
                                                #include "pixel.h"
                                                #include "MySDL.h"
                                                
                                                /* Initialise un personnage pour le joueur */
                                                void player_initialise(Player *player, const char* url)
                                                {
                                                    player->charset = loadImage(url);
                                                    player->v_x = 0;
                                                    player->v_y = 5;
                                                    player->v_s = 0;
                                                    player->player_act.x = 0;
                                                    player->player_act.y = 0;
                                                    player->player_act.w = PLAYER_WIDTH;
                                                    player->player_act.h = player->charset->h / 4;
                                                    player->position.x = 0;
                                                    player->position.y = 100;
                                                    player->jump = 0;
                                                }
                                                
                                                /* Change la frame du personnage si elle
                                                   a été changée depuis plus de x ms */
                                                void player_animation(Player *player, unsigned int x, SDL_Surface* screenMasque)
                                                {
                                                    static unsigned int previousTime = 0;
                                                    if(SDL_GetTicks() - previousTime < x)
                                                        return;
                                                    else
                                                        previousTime = SDL_GetTicks();
                                                
                                                    /* Pour tester si le joueur est proche du sol ou d'une plateforme */
                                                    SDL_Rect temp;
                                                    temp.x = player->position.x;
                                                    temp.y = player->position.y + 30;
                                                    temp.w = PLAYER_WIDTH;
                                                    temp.h = PLAYER_HEIGHT;
                                                
                                                    int nextToFloor = collision(screenMasque, temp);
                                                    int player_direction = (player->player_act.y < PLAYER_Y_LEFT) ? 0 : PLAYER_Y_LEFT;
                                                
                                                    /** GAUCHE <-> DROITE **/
                                                    if(player->v_x < 0 && player->player_act.y < PLAYER_Y_LEFT) /* Si le perso va à gauche, mais qu'il ne regarde pas à gauche */
                                                        player->player_act.y += PLAYER_Y_LEFT;
                                                    else if(player->v_x > 0 && player->player_act.y >= PLAYER_Y_LEFT) /* Sinon si le perso va à droite, mais qu'il ne regarde pas à droite */
                                                        player->player_act.y -= PLAYER_Y_LEFT;
                                                
                                                    /** JUMPING **/
                                                    if(player->jump == 0 && player->v_s > 0) /* Si le perso doit sauter mais qu'il n'est pas prêt */
                                                    {
                                                        player->jump = 1;
                                                        player->player_act.x = PLAYER_X_CAN_JUMP;
                                                        player->player_act.y = (player_direction + PLAYER_Y_JUMPING);
                                                    }
                                                    else if(player->jump) /* Sinon si il peut sauter ou qu'il est entrain de sauter */
                                                    {
                                                        if(player->v_s <= 0 && nextToFloor) /* Si le joueur va atterir sur un sol ou une plateforme */
                                                        {
                                                            if(player->player_act.x > PLAYER_X_STOP_JUMPING) /* Si le perso n'est pas prêt pour courir */
                                                                player->player_act.x -= PLAYER_WIDTH;
                                                            else
                                                            {
                                                                player->jump = 0;
                                                                player->player_act.x = PLAYER_WIDTH;
                                                                player->player_act.y = player_direction;
                                                            }
                                                        }
                                                        else
                                                        {
                                                            player->player_act.x += PLAYER_WIDTH;
                                                            if(player->player_act.x >= player->charset->w)
                                                                player->player_act.x = player->charset->w - PLAYER_WIDTH;
                                                        }
                                                    }
                                                
                                                    /** NORMAL **/
                                                    if(player->player_act.y == player_direction && player->v_s <= 0) /* S'il est entrain de courir */
                                                    {
                                                        if(player->v_x == 0) /* Si le joueur n'avance plus */
                                                            player->player_act.x = 0;
                                                        else
                                                        {
                                                            player->player_act.x += PLAYER_WIDTH;
                                                            if(player->player_act.x >= player->charset->w)
                                                                player->player_act.x = PLAYER_WIDTH;
                                                        }
                                                    }
                                                }
                                                
                                                /* Teste si il y a collision */
                                                int collision(SDL_Surface* screenMasque, SDL_Rect player)
                                                {
                                                    SDL_LockSurface(screenMasque);
                                                    Uint32 pixel;
                                                    Uint8 r, g, b;
                                                    int i, j;
                                                
                                                    player.x += 10;
                                                    player.w -= 20;
                                                    player.h -= 1;
                                                
                                                    if(screenMasque->w < player.x + player.w + 5 ||
                                                       screenMasque->h < player.y + player.h ||
                                                       player.x < 0                          ||
                                                       player.y < 0)
                                                        return 1;
                                                
                                                    for(i = 0; i <= player.w; i++)
                                                        for(j = 0; j <= player.h; j++)
                                                        {
                                                            pixel = getPixel(screenMasque, player.x + i, player.y + j);
                                                            SDL_GetRGB(pixel, screenMasque->format, &r, &g, &b);
                                                            if(r < 20 && g < 20 && b < 20)
                                                            {
                                                                SDL_UnlockSurface(screenMasque);
                                                                return 1;
                                                            }
                                                        }
                                                
                                                    SDL_UnlockSurface(screenMasque);
                                                    return 0;
                                                }
                                                
                                                /* Incémente ou décrémente n pour se rapprocher de 0, ou ne fait rien si n = 0 */
                                                int goZero(int n)
                                                {
                                                    return (n < 0) ? (n + 1) : ((n > 0) ? n - 1 : 0);
                                                }
                                                
                                                /* Bouge le joueur grâce au vecteur vitesse (v_x;v_y) ainsi qu'au vecteur vertical de saut v_s */
                                                void player_move(Player *player, SDL_Surface* screenMasque)
                                                {
                                                    int dx = (int)player->v_x, dy = (int)player->v_y;
                                                
                                                    /* Pour tester si le joueur est proche du sol ou d'une plateforme */
                                                    SDL_Rect temp;
                                                    temp.x = player->position.x;
                                                    temp.y = player->position.y + 40;
                                                    temp.w = PLAYER_WIDTH;
                                                    temp.h = PLAYER_HEIGHT;
                                                
                                                    int i = 0;
                                                    int limitey = (dy < 0) ? -1 : 1;
                                                
                                                    /* saut */
                                                    if(player->v_s > 0 && player->jump) /* Si le joueur doit sauter */
                                                    {
                                                        dy = -player->v_s;
                                                        player->v_s -= 0.5;
                                                        if(player->v_s < 0)
                                                            player->v_s = 0;
                                                    }
                                                
                                                    /* Boucle avec le vecteur vitesse attendu */
                                                    while(1)
                                                    {
                                                        if(dy == limitey)
                                                            break;
                                                
                                                        temp.x = player->position.x + dx;
                                                        temp.y = player->position.y + dy;
                                                
                                                        if(!collision(screenMasque, temp))
                                                        {
                                                            player->position.x += dx;
                                                            player->position.y += dy;
                                                            return;
                                                        }
                                                
                                                        if(i % 2 == 0)
                                                            dx = goZero(dx);
                                                        else
                                                            dy = goZero(dy);
                                                        i++;
                                                    }
                                                
                                                    /* Si ce n'est pas concluant, boucle avec un vecteur vitesse horizontal */
                                                    dx = (int)player->v_x;
                                                    dy = 1;
                                                    while(1)
                                                    {
                                                        if(dx == 0)
                                                            break;
                                                
                                                        temp.x = player->position.x + dx;
                                                        temp.y = player->position.y + dy;
                                                
                                                        if(!collision(screenMasque, temp))
                                                        {
                                                            player->position.x += dx;
                                                            player->position.y += dy;
                                                            return;
                                                        }
                                                
                                                        if(i % 2 == 0)
                                                            dx = goZero(dx);
                                                        else
                                                            dy--;
                                                        i++;
                                                    }
                                                }
                                                

                                                player.h
                                                /*
                                                     ____      _____    _       _____    _   _    _____    _____     _____
                                                    |  __ \   |  ___|  | |     |_   _|  | | | |  |  ___|  |  _  |   |  _  |
                                                    | |  | |  | |_     | |       | |    | |_| |  | |_     | |_| |   | |_| |
                                                    | |  | |  |  _|    | |       | |    |  _  |  |  _|    |  _  /   |  _  |
                                                    | |__| |  | |___   | |___    | |    | | | |  | |___   | | \ \   | | | |
                                                    |____ /   |_____|  |_____|   |_|    |_| |_|  |_____|  |_|  \_\  |_| |_|
                                                
                                                    name     : player.h
                                                    function : Structure (Player), prototypes de player.c et #define des frames du charset
                                                    author   : schadocalex
                                                
                                                */
                                                
                                                #ifndef PLAYER_H_INCLUDED
                                                #define PLAYER_H_INCLUDED
                                                
                                                #define PLAYER_WIDTH 27
                                                #define PLAYER_HEIGHT 39
                                                #define PLAYER_Y_RIGHT 0
                                                #define PLAYER_Y_LEFT (2*PLAYER_HEIGHT)
                                                #define PLAYER_X_CAN_JUMP (5*PLAYER_WIDTH)
                                                #define PLAYER_X_STOP_JUMPING (8*PLAYER_WIDTH)
                                                #define PLAYER_Y_JUMPING PLAYER_HEIGHT
                                                
                                                typedef struct
                                                {
                                                    SDL_Rect player_act; /* Frame du charset actuelle */
                                                    SDL_Rect position; /* Position dans l'écran */
                                                
                                                    SDL_Surface* charset; /* Image charset du joueur */
                                                
                                                    double v_x, v_y, v_s; /* (v_x;v_y) => coordonées du vecteur vitesse */
                                                                          /* v_s => Hauteur du saut, influe sur v_y */
                                                    char jump; /* Est positionné pour sauter ou est entrain de sauter*/
                                                } Player;
                                                
                                                void player_initialise(Player *player, const char* url);
                                                int player_direction(Player *player);
                                                void player_animation(Player *player, unsigned int x, SDL_Surface* screenMasque);
                                                int collision(SDL_Surface* screenMasque, SDL_Rect player);
                                                int goZero(int n);
                                                void player_move(Player *player, SDL_Surface* screenMasque);
                                                
                                                #endif /* PLAYER_H_INCLUDED */
                                                


                                                Fichiers annexes


                                                1.map
                                                12 7
                                                
                                                0 6 0 0
                                                1 6 0 0
                                                2 6 1 0
                                                3 5 3 0
                                                3 6 2 0
                                                4 4 4 0
                                                4 5 2 0
                                                4 6 0 1
                                                5 4 5 0
                                                5 5 7 0
                                                5 6 0 1
                                                6 5 8 0
                                                6 6 0 1
                                                7 5 1 1
                                                7 6 0 1
                                                8 4 3 1
                                                8 5 2 1
                                                8 6 0 1
                                                9 4 4 1
                                                9 5 0 1
                                                9 6 0 1
                                                10 3 5 1
                                                10 4 2 1
                                                10 5 0 1
                                                10 6 0 1
                                                11 3 6 1
                                                11 4 0 1
                                                11 5 0 1
                                                11 6 0 1

                                                Images



                                                player.png
                                                Image utilisateur

                                                grass.png
                                                Image utilisateur

                                                grass_masque.png
                                                Image utilisateur


                                                Les seuls fichiers que je n'ai pas écrits sont pixel.c, pixel.h, events.h et en partie events.c.
                                                • Partager sur Facebook
                                                • Partager sur Twitter
                                                "If debbugging is the process of removing bugs, then programming must be the process of putting them in." (Edsger Dijkstra)
                                                  6 février 2011 à 17:15:10

                                                  Merci schadocalex ! ;)
                                                  Quand tu apportera des modif', édite ton message précédant, et indique nous qu'il y a un changement.

                                                  Reino, désolé, je préfère qu'on reste juste en SDL. J'ai déjà accepté le C++. :ange:
                                                  • Partager sur Facebook
                                                  • Partager sur Twitter
                                                    6 février 2011 à 17:18:24

                                                    C'est ce que je comptais faire. Le C++ accepté ? Pourquoi pas, mais tu devrais ajouter des précisions vis à vis des librairies utilisables, par exemple interdire toute librairie ayant pour but la gestion de l'affichage.
                                                    • Partager sur Facebook
                                                    • Partager sur Twitter
                                                    "If debbugging is the process of removing bugs, then programming must be the process of putting them in." (Edsger Dijkstra)
                                                      6 février 2011 à 17:21:34

                                                      Sympathique comme concours.
                                                      Si j'ai un peu de temps libre, je pondrai une petite chose... :)
                                                      • Partager sur Facebook
                                                      • Partager sur Twitter
                                                      Staff désormais retraité.
                                                        6 février 2011 à 18:27:13

                                                        schadocalex > Il sert à quoi ton programme ? j'ai du mal à saisir. :-°
                                                        • Partager sur Facebook
                                                        • Partager sur Twitter
                                                          6 février 2011 à 18:28:30

                                                          Il n'est pas du tout fini, c'est le début du commencement d'un jeu de plate-forme ^^ En 3 mois, j'ai le temps.
                                                          • Partager sur Facebook
                                                          • Partager sur Twitter
                                                          "If debbugging is the process of removing bugs, then programming must be the process of putting them in." (Edsger Dijkstra)
                                                            6 février 2011 à 20:55:54

                                                            Shadocalex, il est précisé dans les contraintes que nous devons utiliser que la SDL, hors je vois que tu utilises SDL_Image? A t'on le droit? Je pense que oui, vu que c'est un peu la même chose, mais n'étant pas sur, je demande quand même ^^
                                                            • Partager sur Facebook
                                                            • Partager sur Twitter
                                                            http://cpp-rendering.io : Vous trouverez tout ce dont vous avez besoin sur Vulkan / OpenGL et le rendu 3D !
                                                              6 février 2011 à 21:07:37

                                                              Comme je l'ai précisé dans mon premier poste, je ne suis pas si diabolique que ça. :-°
                                                              Vous pouvez utiliser : SDL, SDL_Image, SDL_ttf, SDLP_Anim, SDL_Mixer, SDL_gfx et FMOD.
                                                              • Partager sur Facebook
                                                              • Partager sur Twitter

                                                              [Concours] Après la console, place à la SDL

                                                              × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                                                              × Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
                                                              • Editeur
                                                              • Markdown