Si tu en es encore à ce genre de questions, cela signifie que tu n'as vraisemblablement pas encore le niveau nécessaire pour suivre un tel tuto.

Sans plus d'informations, il nous sera difficile de t'aider. Allez, je tente quand même un truc : tu utilises Code::Blocs (sous Windows notamment), n'est-ce pas ? Dans ce cas, il te suffit de créer un nouveau projet, et là, deux choix possibles s'offrent à toi :

• Tu crées un ou plusieurs nouveau fichiers et tu C/C le contenu de ceux du tuto ;
• Tu inclus les fichiers du tuto à ton projet.

En fait, ton environnement de travail ainsi que ton OS importe peu.

Salut ! J'ai suivi ton tuto, mais j'ai un petit soucis avec la fonction valeur absolue pour affiner les collisions.

En fait, je fais actuellement un jeu de plateforme comme je limite mes FPS a 60, on sens vraiment le pixel/pixel quand on s'approche d'une plateforme, et ça rend un peu le gameplay degeu.

Je voulais savoir si t'avais une solution pour résoudre ce problème qui fais tache dans le gameplay.

Merci d'avance !

Quand tu t'approches d'une plateforme, il y a un test pixel/pixel pour aller la coller, mais il y a juste le test et l'évolution (donc la mise à jour des structures), mais PAS le rendu. Le rendu ne se fait qu'à la fin.

Ah ok, c'est parce que j'ai un peu modifier ton code, j'ai enlevé la fonction 'Evolue', ça doit être pour ça, je vais regarder et modifier alors, merci !

Sinon, j'ai un deuxième soucis, c'est que dans mon jeu, pour déclencher un saut, il faut que le personnage soit au sol, autrement dit, qu'il y ait collision, or, le code ne permet jamais la collision, puisque le déplacement n'est permis que lorsque qu'il n'y a pas collision. Est ce que tu aurais une technique pour pallier a ce problème ?

Voici mon code pour te situer mon problème :

<spoil>

int game(SDL_Surface* screen, Level* lvl)
{
    screen=SDL_SetVideoMode(lvl->screenWidth,lvl->screenHeight,32,SDL_HWSURFACE|SDL_DOUBLEBUF);

    /* ttf */

    TTF_Init();
    TTF_Font *police = TTF_OpenFont("package/polices/police.ttf",20);

    SDL_Surface* vies;

    char showLives[255];

    SDL_Color color = {237,28,36};

    int lives = 10;

    SDL_Rect rectLives; rectLives.x=668; rectLives.y=13;

    /* fin ttf */

    Sprite* perso=malloc(sizeof(Sprite));
    if(perso==NULL)
        return 1;

    Input in;
    memset(&in,0,sizeof(in));
    int running=1;

    unsigned int frameLimit = SDL_GetTicks() + 16;

    perso->img=SDL_CreateRGBSurface(SDL_HWSURFACE,15,15,32,0,0,0,0);
    perso->rect.x=lvl->rectFirst.x;
    perso->rect.y=lvl->rectFirst.y;
    perso->rect.w=16;
    perso->rect.h=32;

    /* Animation */

    SDL_Surface* playerLeft = SDL_LoadBMP("package/img/persoGauche.bmp");
    SDL_Surface* playerRight = SDL_LoadBMP("package/img/persoDroite.bmp");


    SDL_SetColorKey(playerLeft,SDL_SRCCOLORKEY,SDL_MapRGB(playerLeft->format,0,255,0));
    SDL_SetColorKey(playerRight,SDL_SRCCOLORKEY,SDL_MapRGB(playerRight->format,0,255,0));


    Animation* playerLeftAnim=initAnim(playerLeft,16);
    Animation* playerRightAnim=initAnim(playerRight,16);


    int direction = GAUCHE;

    /* saut */

    int power = 0;
    int jump = 0;

    SDL_Surface* tileSet=SDL_LoadBMP("package/level/tileset.bmp");
    Map* m=initMap(lvl->name,tileSet,lvl->screenWidth,lvl->screenHeight);
    if(m==NULL)
        return 1;

    while(running)
    {
        displayMap(m,screen);

        SDL_FillRect(perso->img,0,0x000000);

        updateEvent(&in);

        if(!in.key[SDLK_UP] && !in.key[SDLK_DOWN] && !in.key[SDLK_LEFT] && !in.key[SDLK_RIGHT])
        {
            playerLeftAnim->numImage=0;
            playerRightAnim->numImage=0;
            setAnimSpeed(playerLeftAnim, 0);
            setAnimSpeed(playerRightAnim, 0);
        }

        if(in.key[SDLK_LEFT])
        {
            perso->vx-=MOVESPEED;
            setAnimSpeed(playerLeftAnim,6);
            direction=GAUCHE;
        }


        if(in.key[SDLK_RIGHT])
        {
            perso->vx+=MOVESPEED;
            setAnimSpeed(playerRightAnim,6);
            direction=DROITE;
        }


        if(movePerso(m,&perso->rect,perso->vx,perso->vy)==2)
        {
            lives-=1;
            perso->rect.x=lvl->rectFirst.x;
            perso->rect.y=lvl->rectFirst.y;
            perso->rect.w=16;
            perso->rect.h=32;
            if(lives==0)
            {
                gameover(screen);
                exit(0);
            }
        }

        if(in.key[SDLK_KP1] && in.key[SDLK_KP2] && in.key[SDLK_KP3])
            lives=99999;
           
        if(in.key[SDLK_SPACE])        // c'est ici que je déclenche le saut
        {
            in.key[SDLK_SPACE]=0;


                jump = 1;
                power = JUMP_POWER_MAX;

        }

        if(jump)
        {
            perso->vy -= power;
            power--;
            if(power == 0)
                jump = 0;
        }

        else if(movePerso(m,&perso->rect,perso->vx,perso->vy)==0)
        {
            perso->vy += power;
            if(power < JUMP_POWER_MAX)
            power++;
        }

        if(movePerso(m,&perso->rect,perso->vx,perso->vy)==2)
        {
            lives-=1;
            perso->rect.x=lvl->rectFirst.x;
            perso->rect.y=lvl->rectFirst.y;
            perso->rect.w=16;
            perso->rect.h=32;
            if(lives==0)
            {
                gameover(screen);
                exit(0);
            }
        }

        if(in.key[SDLK_ESCAPE])
            exit(0);

        if(collisionMap(m,&perso->rect)==3)
        {
            win(screen);
            exit(0);
        }

        /* affichage ttf */

        snprintf(showLives, sizeof(showLives), "Vies : %d", lives);
        vies=TTF_RenderText_Blended(police,showLives,color);

        /* fin */

        affine(m,&perso->rect,perso->vx,perso->vy);
        resetVector(&perso->vx,&perso->vy);

        SDL_BlitSurface(vies,0,screen,&rectLives);

        switch(direction)
        {
        case GAUCHE:
            displayAnim(playerLeftAnim,screen,&perso->rect,m);
            break;
        case DROITE:
            displayAnim(playerRightAnim,screen,&perso->rect,m);
            break;
        }

        delay(frameLimit);
        frameLimit = SDL_GetTicks() + 16;
        SDL_Flip(screen);
    }

    releaseMap(m);
    return 0;
}

</spoil>

En tout cas, merci, c'est cool de pouvoir poser des question a un pro

-
Edité par leoufdu78170611 10 juillet 2013 à 15:21:03

Ce que tu peux faire, c'est dans ta structure de sprite, tu rajoutes une donnée "au_sol", un flag qui vaut 0 ou 1.

Et c'est la fonction Evolue qui le met à jour. 

Ahah !! Merci beaucoup, ça fonctionne !!!

Vraiment, encore merci, c'est trop cool 

Bonjour, juste une question. Dans la fonction CollisionDecor de ton tutoriel : Est-ce qu'il ne vaudrait pas mieux faire un tour de boucle en plus pour les deux ? Parce que voila j'ai le SDL_Rect d'un sprite, et lorsque j'appelle la fonction, la détection de collision foire complètement, alors que si je fait un tour de boucle en plus ça marche très bien. C'est normal ?

J'ai re-écrit la fonction comme ceci :

int collisionMapSprite(Map *M, SDL_Rect S)
{
    int i, j;
    int numtile;
    int xmin, ymin, xmax, ymax;

    if(S.x < 0 || S.x >= M->tileset->width*M->world->nbtilesX + S.w
       || S.y < 0 || S.y >= M->tileset->height*M->world->nbtilesY + S.h)
        return 1;

    xmin = S.x / M->tileset->width;
    ymin = S.y / M->tileset->height;
    xmax = (S.x + S.w - 1) / M->tileset->width;
    ymax = (S.y + S.h - 1) / M->tileset->height;

    for(j = ymin; j < ymax + 1; j++)
    {
        for(i = xmin; i < xmax + 1; i++)
        {
            numtile = M->world->table[j][i];
            if(M->tileset->props[numtile].wall > 0)
                return 1;
        }
    }

    return 0;
}

-
Edité par Halarp27 12 juillet 2013 à 14:28:31

Salut,

Oui c'est normal. Comme expliqué dans le tutoriel, tes indices i&j varient de xmin (ymin) à xmax (ymax) inclus. Donc soit , tu rajoutes un "<=" dans tes boucles for, soit tu laisses comme tu as fait ;).

-
Edité par Bump974 19 juillet 2013 à 12:31:19

Quand sort la deuxième partie?

Salut,

J'ai pas le temps en ce moment, et des remontées de commentaires sur le tuto il y a pas mal de temps m'ont démotivé. 

C'est dommage : ton travail est très bien structuré et très intéressant ! Mais on respecte bien entendu.

En espérant tout de même que tu continueras la rédaction à un moment ou un autre

Fvirtman a écrit:

Salut,

J'ai pas le temps en ce moment, et des remontées de commentaires sur le tuto il y a pas mal de temps m'ont démotivé. 

en tout cas ton tuto est super

Bonjour, je ne trouve pas le code pour l'éditeur :S Où est-t'il ? J'en ai besoin pour l'intégrer à mon jeu Cordialement

Salut, si tu suis le tuto, tu tombes un moment sur "Tous les fichiers", et dedans c'est bien classé. Je viens de vérifier le lien, il est actif...

J'ai trouvé, merci beaucoup, c'était ici : http://fr.openclassrooms.com/informatique/cours/tile-mapping/code-exemple

Hello ! C'est marrant de voir que quand des programmeurs se cassent les dents sur une problématique, il y a souvent une solution majoritaire pratique qui en ressort. Je sais pas si c'est compréhensible comme ça mais j'ai pas voulu prendre le temps de détailler, c'est pas le but de ce message !

J'avais déjà vu ton tuto il y a un an ou deux Fvirtman, mais je ne comprenais pas tout. Actuellement, avec plus d'expérience et un peu de temps libre à côté de mes études, je suis parti sur une série de (mini) jeux 2D (style pong, casse-brique, tetris etc). Je me suis inspiré de ta technique de gestion des évènements, où tu mets à simplement à jour des valeurs que tu check ensuite pour en faire ce que tu veux. Je l'avais également consultée auparavant mais l'aspect technique du tutoriel m'avait rapidement largué.

Je retombe aujourd'hui sur ce tutoriel et j'aimerais donc me lancer dans un jeu de plateforme comme mario mais en simplifié avec ma touche perso.
Je pense que je vais réimplémenter tout ton tuto suivant ma façon de voir la chose et de coder, bien qu'on ait sensiblement le même point de vue pour certaines choses. Ensuite je pourrais intégrer personnellement ce qui était censé être ta partie 3 de ce tutoriel, c'est à dire la gravité et les animations. Je pense pouvoir faire ceci sans trop de soucis, suite à la lecture de quelques messages (en fait j'ai lu les 20pages de ce tuto plus quelques trucs à côté, un peu de lecture de temps en temps ça fait pas de mal :p). Au début j'avais peur de cet aspect "parabole" et "formules mathématiques complexes" car même si je suis plutôt à l'aise en mathématiques et en physique j'ai horreur de tout ce qui est formule et tout, je suis plutôt adepte du "à peu près simplement", ça m'a d'ailleurs réconforté de voir que c'était bien ce genre de technique qui était majoritairement utilisé pour les jeux 2D.

Je comprend que tu as été démotivé surtout si en plus tu es surchargé, je sais ce que c'est et je profite d'ailleurs de ce moment de pseudo-tranquillité pour mes projets persos. Bref tout ça pour pas dire grand chose... J'aurais aimé discuter d'autres choses mais c'est pas forcément le bon endroit !

Un grand merci à toi pour ton expérience et tes divers avis qui m'ont réconforté dans ma manière de penser/coder.

Tant mieux alors !

Moi j'aimerais bien utiliser ta fonction mais elle est privée et je suis pas membre apparemment !

Bonjour,

J'ai réalisé un jeu après avoir lu le tuto (il y a de ça un ans ou 2).

Pour ceux qui sont curieux ou pour ceux qui veulent avoir un exemple de mise en pratique du tile mapping, je vous invite à l'essayer : je l'ai posté ici sur OpenClassrooms.

En tout cas, un grand merci à Fvirtman !

Très bon tutoriel. Auriez-vous une idée pour faire des tuiles orientées à 45°, 25°, que le personnage puisse monter des pentes ?

Bonsoir , en tout cas merci de votre travail sa m'a été d'une grande aide. J'ai voulu essayé avec votre code un système de changement de map sur une image du tileset . Alors voilà ce que j'ai rajouté dans votre code 

Dans la structure:

typedef struct
{
	SDL_Rect R;
	int mur;
	int changerMap;
	
} TileProp;

Dans la fonction ChargerMap_tileset : 

m->props[numtile].mur = 0;
			m->props[numtile].changerMap = 0;
			if (strcmp(buf2,"mur")==0){
				m->props[numtile].mur = 1;
			}
			if(strcmp(buf2, "changerMap") == 0){
				m->props[numtile].changerMap = 2;
			}

Dans la fonction CollisionDecor :

if (carte->props[indicetile].mur){
				return 1;
			}
			if(carte->props[indicetile].changerMap){
				SDL_Rect perso;
				SDL_Surface* screen = NULL;
				carte = ChargerMap("level2.txt",LARGEUR_FENETRE,HAUTEUR_FENETRE);
				screen = SDL_SetVideoMode(LARGEUR_FENETRE,HAUTEUR_FENETRE,32,SDL_HWSURFACE|SDL_DOUBLEBUF);
				AfficherMap(carte,screen,&perso,carte->xscroll,carte->yscroll);
				//exit(-1);
				return 2;
			}

Avec le exit(-1) cela fonctionne très bien mais si je veux afficher une map à la place sa ne fonctionne plus ... 

Merci de votre aide

Salut !

Comme je te proposais sur ton topic, je pense qu'il faut considérer qu'une Map est une map.

Si tu veux plusieurs map, remplis plusieurs instances de la structure Map, par exemple un tableau de Map

J' adore tes tutos Fvirtman !!
Continue celui-ci s'il te plait ....

-
Edité par paolo10 24 février 2015 à 18:13:39

Bonjour Fred,

je te remercie pour ton tutoriel incontournable.. C'est parfait pour poursuivre avec la SDL après le tuto de Mateo.

Excellent aussi comme extension de la partie sur la lecture de fichiers.

Justement j'avais un petit souci à ce niveau.  J'avais pu coder la première partie seul mais la nouvelle version évoluée ne fonctionnait pas. Du coup j'ai récupéré fprog2 dans le fichier fourni. la version du fichier fonctionne mais pas la version que j'avais fait en suivant le tuto. En comparant les deux fichiers j'ai pu remarquer des petites différences et je suis finalement tombé sur celle qui change tout.

Dans le tuto le fichier de niveau commence par la ligne: Tilemapping Version 1.0

Dans l'archive, cette ligne n'est plus là.

Dans le tuto, la fonction chargerMap gère cette ligne en lançant un message d'erreur si elle est pas telle quelle, pour rappel de la manière suivante:

 if (strstr(buf,"Tilemapping Version 1.0")==NULL)

        ErrorQuit("Mauvaise version du fichier level. Ce programme attend la version 1.0\n");

Donc du coup dans l'archive cette ligne n'est plus gérée par la programme étant donné qu'elle est plus dans le fichier texte.

J'avais d'abord vérifié le fgets, mais celui marche bien. C'est le strstr qui déconne.... Je pense que la valeur qu'il renvoie ( un pointeur nul si j'en crois la doc ne fonctionne pas avec le test qui est fait ici? )

Je viens de commencer le C alors je suis un peu vert. Si quelqu'un peut m'expliquer pourquoi cette ligne ne fonctionne pas ( sous CodeBlocks en tous cas) cela pourrait m'éclairer.

Je vous remercie d'avance.

Très bon tutoriel. Auriez-vous une idée pour faire des tuiles orientées à 45°.Puis des calcul pour faire glisser le personnage et les entités dessus?? Et pour des platforme qui bougent entre deux points.

Sinon la suite du tuto vas elle être créé ou il est fini, je le trouve très instructif sur le sujet, de plus en français il n'en existe pas d'autre mieux détaillé sur le web

Merci,

Je n'ai pas le temps de rédiger une suite pour le tuto. 

Donc je pense que je ne le continuerai pas.

Pour les tuiles à 45°, en mémoire, c'est pareil que les tuiles droites : dans l'organisation, dans les collisions.

C'est uniquement l'affichage que tu affiches autrement

bonjour ...s'il vous plait est t'il possible de modifier affichage de map et collision par la technique de detection de couleur ... par exemple quand il voit le blanc il ya collision ... mais le scrolling reste intacte

....

merci d'avance

Salut,

Ta question n'est pas très claire. Dans le principe oui, tu peux modifier ce que tu veux pour que ça fasse ce que tu veux. Le tuto a pour vocation de décrire des généralités et diverses techniques. Ce n'est pas parce que le tuto montre comment faire du pixel perfect en cherchant des pixels non-transparents que tu ne peux pas choisir des pixels bleus ou jaune ou quoi...

ok ok merciiii

Bonjour j'ai un problème sur le déplacement des boules de mon mastermind, je vous mets le code je sais pas où est le problème.

#include <SDL/SDL.h>
#include <string.h>
#include <windows.h>
  
#pragma comment (lib,"sdl.lib")
#pragma comment (lib,"sdlmain.lib")
  
#define LARGEUR_TILE 24
#define HAUTEUR_TILE 16
  
#define NOMBRE_BLOCS_LARGEUR 20
#define NOMBRE_BLOCS_HAUTEUR 20
  
char* table[] = {
"00000000000000000000",
"00000000000000000000",
"00000000000000000000",
"00000000000000000000",
"00010000000007777000",
"00000000000000000000",
"00020000000087777000",
"00000000000087777000",
"00030000000087777000",
"00000000000087777000",
"00040000000087777000",
"00000000000087777000",
"00050000000087777000",
"00000000000087777000",
"00060000000087777000",
"00000000000000000000",
"00000000000000000000",
"00000000000000000000",
"00000000000000000000",
"00000000000000000000"};
  
  
  
void Afficher(SDL_Surface* screen,SDL_Surface* tileset,char** table,int nombre_blocs_largeur,int nombre_blocs_hauteur)
{
    int i,j;
    SDL_Rect Rect_dest;
    SDL_Rect Rect_source;
    Rect_source.w = LARGEUR_TILE;
    Rect_source.h = HAUTEUR_TILE;
    for(i=0;i<nombre_blocs_largeur;i++)
    {
        for(j=0;j<nombre_blocs_hauteur;j++)
        {
            Rect_dest.x = i*LARGEUR_TILE;
            Rect_dest.y = j*HAUTEUR_TILE;
            Rect_source.x = (table[j][i]-'0')*LARGEUR_TILE;
            Rect_source.y = 0;
            SDL_BlitSurface(tileset,&Rect_source,screen,&Rect_dest);
        }
    }
    SDL_Flip(screen);
}
main(int argc,char** argv)
{
int boule;
int i,j;
int tampon=0;
    SDL_Surface* screen,*tileset;
    SDL_Event event;
    SDL_Init(SDL_INIT_VIDEO);
    screen = SDL_SetVideoMode(LARGEUR_TILE*NOMBRE_BLOCS_LARGEUR, HAUTEUR_TILE*NOMBRE_BLOCS_HAUTEUR, 32,SDL_HWSURFACE|SDL_DOUBLEBUF);
    tileset = SDL_LoadBMP("tileset.bmp");
    if (!tileset)
    {
        printf("Echec de chargement tileset1.bmp\n");
        SDL_Quit();
        system("pause");
        exit(-1);
    }
  
    do
    {
        Afficher(screen,tileset,table,NOMBRE_BLOCS_LARGEUR,NOMBRE_BLOCS_HAUTEUR);
        bool done=false;
        while(!done)
        {
            SDL_Event event;
            while(SDL_PollEvent(&event))
            {
                switch (event.type)
                {
                    case SDL_KEYDOWN:
                    {
                        switch (event.key.keysym.sym)
                        {
                              case SDLK_ESCAPE:done=true; break;
                              case SDLK_1: table[14][7]=1;break;
                              case SDLK_2: table[14][8]=2;break;
                              case SDLK_3: table[14][9]=3;break;
                              case SDLK_4: table[14][7]=4;break;
                              case SDLK_5: table[14][7]=5;break;
                              case SDLK_6: table[14][7]=6;break;
                              case SDLK_7: tampon=1; break;  //for(i,y;i<14,j<7;i++,j++);
                        }
                    }
                }
            }
        }
  
    }while (tampon!=1);
    SDL_FreeSurface(tileset);
    SDL_Quit();
    return 0;
}