Partage
  • Partager sur Facebook
  • Partager sur Twitter

Mario sokoban

sweeznicea
    22 septembre 2017 à 16:00:07

     Bonjour! le problème c'est que quand je déplace Mario vers le haut toute la partie droite et en dessous de sa position s'efface ! 

    j'ai réécrit tous le programme mais j'ai toujours le même problème !

    • Partager sur Facebook
    • Partager sur Twitter
    edgarjacobs
      22 septembre 2017 à 17:24:14

      Hello,

      sweeznicea a écrit:

       Bonjour! le problème c'est que quand je déplace Mario vers le haut toute la partie droite et en dessous de sa position s'efface ! 

      Non, le problème c'est que j'ai perdu mon pouvoir de divination, et que donc, sans code de ta part....



      • Partager sur Facebook
      • Partager sur Twitter

      On écrit "j'ai tort", pas "tord" qui est le verbe "tordre" à la 3ème personne de l'indicatif présent

      sweeznicea
        22 septembre 2017 à 19:02:02

        main.c
        #include <stdlib.h>
        #include <stdio.h>
        #include <SDL/SDL.h>
        #include <SDL_image.h>
        #include "constantes.h"
        #include "jeu..h"
        #include "editeur.h"
        int main(int argc, char *argv[])
        {
            SDL_Surface *ecran = NULL, *menu = NULL;
            SDL_Rect positionMenu;
            SDL_Event event;
            int continuer = 1;
            SDL_Init(SDL_INIT_VIDEO);
            SDL_WM_SetIcon(IMG_Load("caisse.jpg"), NULL); // L'icône doit être chargée avant SDL_SetVideoMode
            ecran = SDL_SetVideoMode(LARGEUR_FENETRE, HAUTEUR_FENETRE, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);
            SDL_WM_SetCaption("Mario Sokoban", NULL);
            menu = IMG_Load("menu.jpg");
            positionMenu.x = 0;
            positionMenu.y = 0;
            while (continuer)
            {
                SDL_WaitEvent(&event);
                switch(event.type)
                {
                    case SDL_QUIT:
                        continuer = 0;
                        break;
                    case SDL_KEYDOWN:
                        switch(event.key.keysym.sym)
                        {
                            case SDLK_ESCAPE: // Veut arrêter le jeu
                                continuer = 0;
                                break;
                            case SDLK_KP1: // Demande à jouer
                                jouer(ecran);
                                break;
                            case SDLK_KP2: // Demande l'éditeur de niveaux
                                editeur(ecran);
                                break;
                        }
                        break;
                }
                // Effacement de l'écran
                SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 0, 0, 0));
                SDL_BlitSurface(menu, NULL, ecran, &positionMenu);
                SDL_Flip(ecran);
            }
            SDL_FreeSurface(menu);
            SDL_Quit();
            return EXIT_SUCCESS;
        }
        jeu.c
        #include <stdlib.h>
        #include <stdio.h>
        #include <SDL/SDL.h>
        #include <SDL_image.h>
        #include "constantes.h"
        #include "jeu..h"
        void jouer(SDL_Surface* ecran)
        {
            SDL_Surface *mario[4] = {NULL}; // 4 surfaces pour chacune des directions de mario
            SDL_Surface *mur = NULL, *caisse = NULL, *caisseOK = NULL, *objectif = NULL, *marioActuel = NULL;
            SDL_Rect position, positionJoueur;
            SDL_Event event;
            int continuer = 1, objectifsRestants = 0, i = 0, j = 0;
            int carte[NB_BLOCS_LARGEUR][NB_BLOCS_HAUTEUR] = {0};
            // Chargement des sprites (décors, personnage...)
            mur = IMG_Load("mur.jpg");
            caisse = IMG_Load("caisse.jpg");
            caisseOK = IMG_Load("caisse_ok.jpg");
            objectif = IMG_Load("objectif.png");
            mario[BAS] = IMG_Load("mario_bas.gif");
            mario[GAUCHE] = IMG_Load("mario_gauche.gif");
            mario[HAUT] = IMG_Load("mario_haut.gif");
            mario[DROITE] = IMG_Load("mario_droite.gif");
            marioActuel = mario[BAS]; // Mario sera dirigé vers le bas au départ
            // Chargement du niveau
            if (!chargerNiveau(carte))
                exit(EXIT_FAILURE); // On arrête le jeu si on n'a pas pu charger le niveau
            // Recherche de la position de Mario au départ
            for (i = 0 ; i < NB_BLOCS_LARGEUR ; i++)
            {
                for (j = 0 ; j < NB_BLOCS_HAUTEUR ; j++)
                {
                    if (carte[i][j] == MARIO) // Si Mario se trouve à cette position sur la carte
                    {
                        positionJoueur.x = i;
                        positionJoueur.y = j;
                        carte[i][j] = VIDE;
                    }
                }
            }
            // Activation de la répétition des touches
            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_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;
                }
                break;
        }
                // Effacement de l'écran
                SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 255, 255, 255));
                // Placement des objets à l'écran
                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:
                                SDL_BlitSurface(mur, 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;
                        }
                    }
                }
                // Si on n'a trouvé aucun objectif sur la carte, c'est qu'on a gagné
                if (!objectifsRestants)
                    continuer = 0;
                // On place le joueur à la bonne position
                position.x = positionJoueur.x * TAILLE_BLOC;
                position.y = positionJoueur.y * TAILLE_BLOC;
                SDL_BlitSurface(marioActuel, NULL, ecran, &position);
                SDL_Flip(ecran);
            }
            // Désactivation de la répétition des touches (remise à 0)
            SDL_EnableKeyRepeat(0, 0);
            // Libération des surfaces chargées
            SDL_FreeSurface(mur);
            SDL_FreeSurface(caisse);
            SDL_FreeSurface(caisseOK);
            SDL_FreeSurface(objectif);
            for (i = 0 ; i < 4 ; i++)
                SDL_FreeSurface(mario[i]);
        }
        void deplacerJoueur(int carte[][NB_BLOCS_HAUTEUR], SDL_Rect *pos, int direction)
        {
            switch(direction)
            {
                case HAUT:
                    if (pos->y - 1 < 0) // Si le joueur dépasse l'écran, on arrête
                        break;
                    if (carte[pos->x][pos->y - 1] == MUR) // S'il y a un mur, on arrête
                        break;
                    // Si on veut pousser une caisse, il faut vérifier qu'il n'y a pas de mur derrière (ou une autre caisse, ou la limite du monde)
                    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 ||
                        carte[pos->x][pos->y - 2] == CAISSE || carte[pos->x][pos->y - 2] == CAISSE_OK))
                        break;
                    // Si on arrive là, c'est qu'on peut déplacer le joueur !
                    // On vérifie d'abord s'il y a une caisse à déplacer
                    deplacerCaisse(&carte[pos->x][pos->y - 1], &carte[pos->x][pos->y - 2]);
                    pos->y--; // On peut enfin faire monter le joueur (oufff !)
                    break;
                case BAS:
                    if (pos->y + 1 >= NB_BLOCS_HAUTEUR)
                        break;
                    if (carte[pos->x][pos->y + 1] == MUR)
                        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 ||
                        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] == MUR)
                        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 ||
                        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] == MUR)
                        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 ||
                        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;
            }
        }
        editeur.c
        #include <stdlib.h>
        #include <stdio.h>
        #include <SDL/SDL.h>
        #include <SDL_image.h>
        #include "constantes.h"
        #include "editeur.h"
        #include "fichier.h"
        void editeur(SDL_Surface* ecran)
        {
            SDL_Surface *mur = NULL, *caisse = NULL, *objectif = NULL, *mario = NULL;
            SDL_Rect position;
            SDL_Event event;
            int continuer = 1, clicGaucheEnCours = 0, clicDroitEnCours = 0;
            int objetActuel = MUR, i = 0, j = 0;
            int carte[NB_BLOCS_LARGEUR][NB_BLOCS_HAUTEUR] = {0};
            // Chargement des objets et du niveau
            mur = IMG_Load("mur.jpg");
            caisse = IMG_Load("caisse.jpg");
            objectif = IMG_Load("objectif.png");
            mario = IMG_Load("mario_bas.gif");
            if (!chargerNiveau(carte))
                exit(EXIT_FAILURE);
            // Boucle infinie de l'éditeur
            while (continuer)
            {
                SDL_WaitEvent(&event);
                switch(event.type)
                {
                    case SDL_QUIT:
                        continuer = 0;
                        break;
                    case SDL_MOUSEBUTTONDOWN:
                        if (event.button.button == SDL_BUTTON_LEFT)
                        {
                            // On met l'objet actuellement choisi (mur, caisse...) à l'endroit du clic
                            carte[event.button.x / TAILLE_BLOC][event.button.y / TAILLE_BLOC] = objetActuel;
                            clicGaucheEnCours = 1; // On active un booléen pour retenir qu'un bouton est enfoncé
                        }
                        else if (event.button.button == SDL_BUTTON_RIGHT) // Le clic droit sert à effacer
                        {
                            carte[event.button.x / TAILLE_BLOC][event.button.y /TAILLE_BLOC] = VIDE;
                            clicDroitEnCours = 1;
                        }
                        break;
                    case SDL_MOUSEBUTTONUP: // On désactive le booléen qui disait qu'un bouton était enfoncé
                        if (event.button.button == SDL_BUTTON_LEFT)
                            clicGaucheEnCours = 0;
                        else if (event.button.button == SDL_BUTTON_RIGHT)
                            clicDroitEnCours = 0;
                        break;
                    case SDL_MOUSEMOTION:
                        if (clicGaucheEnCours) // Si on déplace la souris et que le bouton gauche de la souris est enfoncé
                        {
                            carte[event.motion.x / TAILLE_BLOC][event.motion.y / TAILLE_BLOC] = objetActuel;
                        }
                        else if (clicDroitEnCours) // Pareil pour le bouton droit de la souris
                        {
                            carte[event.motion.x / TAILLE_BLOC][event.motion.y / TAILLE_BLOC] = VIDE;
                        }
                        break;
                    case SDL_KEYDOWN:
                        switch(event.key.keysym.sym)
                        {
                            case SDLK_ESCAPE:
                                continuer = 0;
                                break;
                            case SDLK_s:
                                sauvegarderNiveau(carte);
                                break;
                            case SDLK_c:
                                chargerNiveau(carte);
                                break;
                            case SDLK_KP1:
                                objetActuel = MUR;
                                break;
                            case SDLK_KP2:
                                objetActuel = CAISSE;
                                break;
                            case SDLK_KP3:
                                objetActuel = OBJECTIF;
                                break;
                            case SDLK_KP4:
                                objetActuel = MARIO;
                                break;
                        }
                        break;
                }
                // Effacement de l'écran
                SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 255, 255, 255));
                // Placement des objets à l'écran
                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:
                                SDL_BlitSurface(mur, NULL, ecran, &position);
                                break;
                            case CAISSE:
                                SDL_BlitSurface(caisse, NULL, ecran, &position);
                                break;
                            case OBJECTIF:
                                SDL_BlitSurface(objectif, NULL, ecran, &position);
                                break;
                            case MARIO:
                                SDL_BlitSurface(mario, NULL, ecran, &position);
                                break;
                        }
                    }
                }
                // Mise à jour de l'écran
                SDL_Flip(ecran);
            }
            SDL_FreeSurface(mur);
            SDL_FreeSurface(caisse);
            SDL_FreeSurface(objectif);
            SDL_FreeSurface(mario);
        }
        fichier.c
        #include <stdlib.h>
        #include <stdio.h>
        #include <SDL/SDL.h>
        #include <SDL_image.h>
        #include "constantes.h"
        #include "fichier.h"
        int chargerNiveau(int niveau[][NB_BLOCS_HAUTEUR])
        {
            FILE* fichier = NULL;
            char ligneFichier[NB_BLOCS_LARGEUR * NB_BLOCS_HAUTEUR + 1] = {0};
            int i = 0, j = 0;
            fichier = fopen("niveaux.txt", "r");
            if (fichier == NULL)
                return 0;
            fgets(ligneFichier, NB_BLOCS_LARGEUR * NB_BLOCS_HAUTEUR + 1, fichier);
            for (i = 0 ; i < NB_BLOCS_LARGEUR ; i++)
            {
                for (j = 0 ; j < NB_BLOCS_HAUTEUR ; j++)
                {
                    switch (ligneFichier[(i * NB_BLOCS_LARGEUR) + j])
                    {
                        case '0':
                            niveau[j][i] = 0;
                            break;
                        case '1':
                            niveau[j][i] = 1;
                            break;
                        case '2':
                            niveau[j][i] = 2;
                            break;
                        case '3':
                            niveau[j][i] = 3;
                            break;
                        case '4':
                            niveau[j][i] = 4;
                            break;
                    }
                }
            }
            fclose(fichier);
            return 1;
        }
        int sauvegarderNiveau(int niveau[][NB_BLOCS_HAUTEUR])
        {
            FILE* fichier = NULL;
            int i = 0, j = 0;
            fichier = fopen("niveaux.lvl", "w");
            if (fichier == NULL)
                return 0;
            for (i = 0 ; i < NB_BLOCS_LARGEUR ; i++)
            {
                for (j = 0 ; j < NB_BLOCS_HAUTEUR ; j++)
                {
                    fprintf(fichier, "%d", niveau[j][i]);
                }
            }
            fclose(fichier);
            return 1;
        }

        -
        Edité par sweeznicea 22 septembre 2017 à 19:04:15

        • Partager sur Facebook
        • Partager sur Twitter

        Mario sokoban

        × 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