[déplacé BAR -> C] Chronometre dans un jeu

wallaby83140 Messages postés 9 Date d'inscription vendredi 19 février 2010 Statut Membre Dernière intervention 10 mai 2011 - 26 févr. 2010 à 20:37
ucfoutu Messages postés 18038 Date d'inscription lundi 7 décembre 2009 Statut Modérateur Dernière intervention 11 avril 2018 - 26 févr. 2010 à 20:55
Bonjour,

Je travaille sur un jeu où j'ai mis un chronomètre.
Mais ce chronomètre ne se déclench que los d'une action dans le jeu.
Exemple: je bouge le crnomètre marche ,je m'arrete de bouger le chronomètre se met sur pause.Et sa je ne veux pas!!

Pourriez-vous m'aider?

Voici mon code source

/*
    jeu.c

    Par Wallaby le 23/01/2010 à 11:22
    Dernière modification le 30/01/2010 à 11:09

    Rôle: Fonction de jeu.
*/

#include <stdlib.h>
#include <stdio.h>
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
#include <FMOD/fmod.h>
#include <TTF/SDL_ttf.h>

#include "constante.h"
#include "jeu.h"

void jouer(SDL_Surface* ecran, int level)
{
    SDL_Surface *mario[4] = {NULL};
    SDL_Surface *murMM NULL, *plafond NULL, *caisse = NULL, *caisseOK = NULL, *objectif = NULL, *marioActuel = NULL, *son = NULL, *murMB = NULL, *murHM = NULL;
    SDL_Rect position, positionJoueur, positionSon;
    SDL_Event event;
    int continuer = 1;
    int objectifsRestants 0, i 0, j = 0, niveau = 0;
    int carte[NB_BLOCS_LARGEUR][NB_BLOCS_HAUTEUR] = {0};
    static int copieLvl = 1;
    static int lvl = 0;
    lvl = copieLvl;
    SDL_Surface *texte = NULL;
    SDL_Rect positionTemps;
    TTF_Font *police = NULL;
    SDL_Color couleurNoire {0, 0, 0}, couleurRouge {255, 0,0};
    int tempsActuel 0, tempsPrecedent 0, compteur = 0, heure = 0, minute = 0, seconde = 0, Millisecondes=0;
    char temps[20] = "";

    murMM = IMG_Load("MMM.jpg");
    murMB = IMG_Load("MMB.png");
    murHM = IMG_Load("MMH.jpg");
    plafond = IMG_Load("plafond.jpg");
    caisse = IMG_Load("caisse2.png");
    caisseOK = IMG_Load("caisse_ok.png");
    objectif = IMG_Load("objectif.png");
    mario[HAUT] = IMG_Load("mario_haut.bmp");
    mario[BAS] = IMG_Load("mario_bas.bmp");
    mario[DROITE] = IMG_Load("mario_droite.bmp");
    mario[GAUCHE] = IMG_Load("mario_gauche.bmp");
    son = IMG_Load("son4.bmp");

    marioActuel = mario[BAS];

    if(!chargerNiveau(carte, level))
        exit(EXIT_FAILURE);

        TTF_Init();



    police = TTF_OpenFont("angelina.ttf", 20);

    tempsActuel = SDL_GetTicks();
    sprintf(temps, "Temps : %d : %d : %d ", heure, minute, seconde);
    texte = TTF_RenderText_Solid(police, temps, couleurNoire);


    for(i = 0; i <NB_BLOCS_LARGEUR; i++)
    {
        for(j = 0; j<NB_BLOCS_HAUTEUR; j++)
        {
            if(carte[i][j] == MARIO)
            {
                positionJoueur.x = i;
                positionJoueur.y = j;

                carte[i][j] = VIDE;
            }
        }
    }

    SDL_EnableKeyRepeat(100,100);

    while(continuer)
    {
        SDL_WaitEvent( &event);
        switch(event.type)
        {
            case SDL_QUIT:
                continuer = 0;
                break;

            case SDL_KEYDOWN:
                switch(event.key.keysym.sym)
                {
                    case SDLK_p:
                        if(FSOUND_GetPaused(1))
                         {   FSOUND_SetPaused(FSOUND_ALL, 0);
                             son = IMG_Load("son4.bmp");
                                positionSon.x = 0;
                                positionSon.y = 0;
                         }
                        else
                        {
                            FSOUND_SetPaused(FSOUND_ALL, 1);
                             son = IMG_Load("son3.bmp");
                                positionSon.x = 0;
                                positionSon.y = 0;
                        }
                        break;
                    case SDLK_ESCAPE:
                        continuer = 0;
                        break;
                    case SDLK_UP:
                        marioActuel = mario[HAUT];
                        deplacerJoueur(carte, &positionJoueur, HAUT);
                        break;
                    case SDLK_DOWN:
                        marioActuel = mario[BAS];
                        deplacerJoueur(carte, &positionJoueur, BAS);
                        break;
                    case SDLK_RIGHT:
                        marioActuel = mario[DROITE];
                        deplacerJoueur(carte, &positionJoueur, DROITE);
                        break;
                    case SDLK_LEFT:
                        marioActuel = mario[GAUCHE];
                        deplacerJoueur(carte, &positionJoueur, GAUCHE);
                        break;

                        case SDLK_w:
                        marioActuel = mario[HAUT];
                        deplacerJoueur(carte, &positionJoueur, HAUT);
                        break;
                    case SDLK_s:
                        marioActuel = mario[BAS];
                        deplacerJoueur(carte, &positionJoueur, BAS);
                        break;
                    case SDLK_d:
                        marioActuel = mario[DROITE];
                        deplacerJoueur(carte, &positionJoueur, DROITE);
                        break;
                    case SDLK_a:
                        marioActuel = mario[GAUCHE];
                        deplacerJoueur(carte, &positionJoueur, GAUCHE);
                        break;
                    case SDLK_r:
                        jouer(ecran, level);
                        continuer = 0;
                        break;
                    case SDLK_PAGEUP:
                        continuer = 0;
                        jouer(ecran, level + 1);
                        break;
                   case SDLK_PAGEDOWN:
                        if(level == 1)
                        break;

                }
                break;
        }

        SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 255, 255, 255));

        objectifsRestants = 0;

        for(i = 0; i<NB_BLOCS_LARGEUR; i++)
        {
            for(j = 0; j<NB_BLOCS_HAUTEUR; j++)
            {
                position.x = i*TAILLE_BLOC;
                position.y = j*TAILLE_BLOC;

                switch( carte[i][j])
                {
                    case MUR_M_M:
                        SDL_BlitSurface(murMM, NULL, ecran, &position);
                        break;
                    case CAISSE:
                        SDL_BlitSurface(caisse, NULL, ecran, &position);
                        break;
                    case CAISSE_OK:
                        SDL_BlitSurface(caisseOK, NULL, ecran, &position);
                        break;
                    case OBJECTIF:
                        SDL_BlitSurface(objectif, NULL, ecran, &position);
                        objectifsRestants = 1;
                        break;
                    case MUR_M_H:
                        SDL_BlitSurface(murHM, NULL, ecran, &position);
                        break;
                    case MUR_M_B:
                        SDL_BlitSurface(murMB, NULL, ecran, &position);
                        break;
                    case PLAFOND:
                        SDL_BlitSurface(plafond, NULL, ecran, &position);
                        break;
                }
            }
        }

        if(objectifsRestants == 0)
        {
            continuer = 0;

            if(level < TOTALLEVEL)
            jouer(ecran,level + 1);
        }

        position.x = positionJoueur.x * TAILLE_BLOC;
        position.y = positionJoueur.y * TAILLE_BLOC;

        SDL_BlitSurface(marioActuel, NULL, ecran, &position);
        SDL_BlitSurface(son, NULL, ecran, &positionSon);
        SDL_Flip(ecran);

        SDL_PollEvent(&event);
        switch(event.type)
        {
            case SDL_QUIT:
                continuer = 0;
                break;
        }

        tempsActuel = SDL_GetTicks();
        if (tempsActuel - tempsPrecedent >= 100)
        {
            Millisecondes+=tempsActuel - tempsPrecedent;
            if(Millisecondes>=1000)
           {
                Millisecondes=Millisecondes%1000;
                seconde ++;
            }
            if(seconde >= 60)
            {
                minute ++;
                seconde=seconde%60;
            }
            if(minute >= 60)
            {
                heure ++;
                minute=minute%60;
            }

           sprintf(temps, "Temps : %d : %d : %d", heure, minute, seconde );

           SDL_FreeSurface(texte);
           texte = TTF_RenderText_Solid(police, temps, couleurNoire);
            tempsPrecedent = tempsActuel;
        }


        positionTemps.x = 470;
        positionTemps.y = 10;
        SDL_BlitSurface(texte, NULL, ecran, &positionTemps);
        SDL_Flip(ecran);



    }



    SDL_EnableKeyRepeat(0,0);

    SDL_FreeSurface(son);
    SDL_FreeSurface(murMM);
    SDL_FreeSurface(caisse);
    SDL_FreeSurface(caisseOK);
    SDL_FreeSurface(objectif);
    for(i = 0; i<4; i++)
        SDL_FreeSurface(mario[i]);
    TTF_CloseFont(police);
    TTF_Quit();

}

void deplacerJoueur(int carte[][NB_BLOCS_HAUTEUR], SDL_Rect *pos, int direction)
{
    switch(direction)
    {
        case HAUT:
            if(pos->y -1<0)
                break;
            if(carte[pos->x][pos->y -1] == MUR_M_B)
                break;
            if(carte[pos->x][pos->y -1] == PLAFOND)
                break;
            if(carte[pos->x][pos->y -1] == MUR_M_M)
                break;
            if(carte[pos->x][pos->y -1] == MUR_M_H)
                break;

             if ((carte[pos->x][pos->y - 1] == CAISSE || carte[pos->x][pos->y - 1] == CAISSE_OK) &&
            (pos->y - 2 < 0 || carte[pos->x][pos->y - 2] == PLAFOND ||
            carte[pos->x][pos->y - 2] == CAISSE || carte[pos->x][pos->y - 2] == CAISSE_OK))
                break;
            if ((carte[pos->x][pos->y - 1] == CAISSE || carte[pos->x][pos->y - 1] == CAISSE_OK) &&
            (pos->y - 2 < 0 || carte[pos->x][pos->y - 2] == MUR_M_H ||
            carte[pos->x][pos->y - 2] == CAISSE || carte[pos->x][pos->y - 2] == CAISSE_OK))
                break;
            if ((carte[pos->x][pos->y - 1] == CAISSE || carte[pos->x][pos->y - 1] == CAISSE_OK) &&
            (pos->y - 2 < 0 || carte[pos->x][pos->y - 2] == MUR_M_B ||
            carte[pos->x][pos->y - 2] == CAISSE || carte[pos->x][pos->y - 2] == CAISSE_OK))
                break;

            if ((carte[pos->x][pos->y - 1] == CAISSE || carte[pos->x][pos->y - 1] == CAISSE_OK) &&
            (pos->y - 2 < 0 || carte[pos->x][pos->y - 2] == MUR_M_M ||
            carte[pos->x][pos->y - 2] == CAISSE || carte[pos->x][pos->y - 2] == CAISSE_OK))
                break;

            deplacerCaisse(&carte[pos->x][pos->y -1], &carte[pos->x][pos->y -2]);

            pos-> y--;

            break;

            case BAS:

             if(pos->y +1>= NB_BLOCS_HAUTEUR)
                break;
            if(carte[pos->x][pos->y +1] == PLAFOND)
                break;
            if(carte[pos->x][pos->y +1] == MUR_M_H)
                break;

             if ((carte[pos->x][pos->y +1] == CAISSE || carte[pos->x][pos->y + 1] == CAISSE_OK) &&
            (pos->y +2>NB_BLOCS_HAUTEUR|| carte[pos->x][pos->y +2] PLAFOND ||
            carte[pos->x][pos->y +2] == CAISSE || carte[pos->x][pos->y +2] == CAISSE_OK))
                break;
            if ((carte[pos->x][pos->y +1] == CAISSE || carte[pos->x][pos->y + 1] == CAISSE_OK) &&
            (pos->y +2>NB_BLOCS_HAUTEUR|| carte[pos->x][pos->y +2] MUR_M_H ||
            carte[pos->x][pos->y +2] == CAISSE || carte[pos->x][pos->y +2] == CAISSE_OK))
                break;

            deplacerCaisse(&carte[pos->x][pos->y +1], &carte[pos->x][pos->y +2]);

            pos-> y++;

            break;

            case GAUCHE:

             if(pos->x -1<0)
                break;
            if(carte[pos->x -1][pos->y] == PLAFOND)
                break;
            if(carte[pos->x -1][pos->y] == MUR_M_B)
                break;
            if(carte[pos->x -1][pos->y] == MUR_M_M)
                break;
            if(carte[pos->x -1][pos->y] == MUR_M_H)
                break;

            if ((carte[pos->x -1][pos->y] == CAISSE || carte[pos->x -1][pos->y] == CAISSE_OK) &&
            (pos->x - 2 < 0 || carte[pos->x -2][pos->y] == MUR_M_B ||
            carte[pos->x -2][pos->y] == CAISSE || carte[pos->x -2][pos->y] == CAISSE_OK))
                break;
            if ((carte[pos->x -1][pos->y] == CAISSE || carte[pos->x -1][pos->y] == CAISSE_OK) &&
            (pos->x - 2 < 0 || carte[pos->x -2][pos->y] == MUR_M_H ||
            carte[pos->x -2][pos->y] == CAISSE || carte[pos->x -2][pos->y] == CAISSE_OK))
                break;
            if ((carte[pos->x -1][pos->y] == CAISSE || carte[pos->x -1][pos->y] == CAISSE_OK) &&
            (pos->x - 2 < 0 || carte[pos->x -2][pos->y] == MUR_M_M ||
            carte[pos->x -2][pos->y] == CAISSE || carte[pos->x -2][pos->y] == CAISSE_OK))
                break;

            deplacerCaisse(&carte[pos->x -1][pos->y], &carte[pos->x -2][pos->y]);

            pos-> x--;

            break;

            case DROITE:

             if(pos->x +1>= NB_BLOCS_LARGEUR)
                break;
            if(carte[pos->x +1][pos->y] == PLAFOND)
                break;
            if(carte[pos->x +1][pos->y] == MUR_M_B)
                break;
            if(carte[pos->x +1][pos->y] == MUR_M_M)
                break;
            if(carte[pos->x +1][pos->y] == MUR_M_H)
                break;

            if ((carte[pos->x +1][pos->y] == CAISSE || carte[pos->x +1][pos->y] == CAISSE_OK) &&
            (pos->x +2>NB_BLOCS_LARGEUR || carte[pos->x +2][pos->y] PLAFOND ||
            carte[pos->x +2][pos->y] == CAISSE || carte[pos->x +2][pos->y] == CAISSE_OK))
                break;
            if ((carte[pos->x +1][pos->y] == CAISSE || carte[pos->x +1][pos->y] == CAISSE_OK) &&
            (pos->x +2>NB_BLOCS_LARGEUR || carte[pos->x +2][pos->y] MUR_M_H ||
            carte[pos->x +2][pos->y] == CAISSE || carte[pos->x +2][pos->y] == CAISSE_OK))
                break;

            if ((carte[pos->x + 1][pos->y] == CAISSE || carte[pos->x + 1][pos->y] == CAISSE_OK) &&
                (pos->x + 2 >NB_BLOCS_LARGEUR || carte[pos->x + 2][pos->y] MUR_M_M ||
                carte[pos->x + 2][pos->y] == CAISSE || carte[pos->x + 2][pos->y] == CAISSE_OK))
                break;

            if ((carte[pos->x + 1][pos->y] == CAISSE || carte[pos->x + 1][pos->y] == CAISSE_OK) &&
                (pos->x + 2 >NB_BLOCS_LARGEUR || carte[pos->x + 2][pos->y] MUR_M_B ||
                carte[pos->x + 2][pos->y] == CAISSE || carte[pos->x + 2][pos->y] == CAISSE_OK))
                break;

            deplacerCaisse(&carte[pos->x +1][pos->y], &carte[pos->x +2][pos->y]);

            pos-> x++;

            break;
    }
}

void deplacerCaisse(int *premiereCase, int *secondeCase)
{
    if(*premiereCase CAISSE || *premiereCase CAISSE_OK)
    {
        if(*secondeCase == OBJECTIF)
            *secondeCase = CAISSE_OK;

        else
            *secondeCase = CAISSE;

        if(*premiereCase == CAISSE_OK)
            *premiereCase = OBJECTIF;

        else
            *premiereCase = VIDE;
    }
}



En vous remercian d'avance.
A voir également:

3 réponses

wallaby83140 Messages postés 9 Date d'inscription vendredi 19 février 2010 Statut Membre Dernière intervention 10 mai 2011
26 févr. 2010 à 20:39
Oupsj'ai oublié je travaille en langage C sous Code Blocks en SDL
0
wallaby83140 Messages postés 9 Date d'inscription vendredi 19 février 2010 Statut Membre Dernière intervention 10 mai 2011
26 févr. 2010 à 20:40
Rohh en SDL
0
ucfoutu Messages postés 18038 Date d'inscription lundi 7 décembre 2009 Statut Modérateur Dernière intervention 11 avril 2018 234
26 févr. 2010 à 20:55
Enfin, quoi ... en n'importe quoi...
Je dirais volontiers que pour l'instant, tu développes dans le bar ...
Pour preuve :

CodeS-SourceS > Le Bar > Discussions libres

Et ton chrono, lui, il doit également faire du n'importe quoi ?
____________________
Vous aimez Codes-Sources ? Il vous aide ? Cliquez ici pour l'aider à continuer
Cliquer sur "Réponse acceptée" en bas d'une solution adéquate est
0