Partage
  • Partager sur Facebook
  • Partager sur Twitter

[MARIO SOKOBAN] 2 bugs : texture et condition

    22 décembre 2021 à 15:37:16

    Salut,

    Je suis en train de finir le TP Mario Sokoban. il me reste l'enregistrement de niveaux, et de la progression d'une potentielle aventure, ainsi qu'une page intermédiaire avec le choix de jouer à ses niveaux édités ou non, à faire.

    Cependant, j'ai 2 bugs dans mes fichiers que je n'arrive pas à résoudre.

    Ligne 282 du fichier main.c, j'ai dû mettre un SDL_Delay(200) car le if(jouer) soit if(0) lorsque l'on veut édité un niveau ignore le else, après avoir choisi un mode et l'avoir quitté.

    Ligne 587, dans la fonction appelMenuPause(), impossible de changer la texture du bouton de sauvegarde.

    Les conditions délimitant la zone cliquable du bouton marchent, d'après les messagebox qui sont apparus.

    Code : https://github.com/iconic-i-clash/mario-sokoban.

    Savez-vous d'où viennent ces bugs ?

    Merci pour votre aide !

    -
    Edité par Iconic I Clash 9 janvier 2022 à 18:15:56

    • Partager sur Facebook
    • Partager sur Twitter
      22 décembre 2021 à 16:00:09

      Quand même ! Vu le nombre de ligne qui dépasse les 1000 il faut utiliser un débugueur !

      Tiens, en voila un sous Windows sans SDL en 245 lignes : https://chgi.developpez.com/wincode/sokoban/

      • Partager sur Facebook
      • Partager sur Twitter
        22 décembre 2021 à 16:34:37

        Plusieurs notes :

        • Pitié code en anglais.
        • Ta fonction main est absolument scandaleuse
        • Évite d'inclure des binaires dans un dépôt SCM (.dll, .exe)
        • Les évènements c'est mieux de les dépiler en boucle, sinon c'est lent et il t'en restera après étude d'un évènement interessé

        Pour ton problème, va falloir debugger ou au pire rajouter des printf de debugage. Mais en découpant plus soigneusement tu arriveras à diagnostiquer mieux le problème.

        • Partager sur Facebook
        • Partager sur Twitter

        l'azerty est aux dispositions ce que subversion est aux SCM

          22 décembre 2021 à 17:24:55

          Salut,

          Merci pour vos réponses.

          @markand, pourquoi est-ce que ma fonction main est scandaleuse ?

          • Partager sur Facebook
          • Partager sur Twitter
            22 décembre 2021 à 23:11:47

            Iconic I Clash a écrit:

            pourquoi est-ce que ma fonction main est scandaleuse ?

            Tu y déclares plus de 80 variables (j'ai arrêté de compter à ce stade) et elle fait plus de 550 lignes !!!!

            #include <stdlib.h>
            #include <stdio.h>
            #include <SDL.h>
            #include <SDL_image.h>
            #include <math.h>
            #include <string.h>
            #include "constantes.h"
            #include "menu.h"
            #include "jeu.h"
            #include "editeur.h"
            #include "texture.h"
            #define ESPACEMENT_BOUTTONS 0.5
            
            
            int main(int argc, char *argv[])
            {
                double espaceVideW, espaceVideH, coteBoutonPause, distanceBoutonPause;
                int ajouterMur = 0, ajouter = 0, effacer = 0, y, coteRedimensionne, boucleCroissante, r, g, b, retourMenu, ligne1, ligne2, ligne3, ligne4, case1, case2, case3, case4, marioGenere = 0, tempsAttente = 0, tempsActuel = 0, tempsPrecedent = 0, carte[LIGNES][NB_CASES], continuer = 1, i = 0, jouer;
                SDL_Window *window = NULL;
                SDL_Renderer *renderer = NULL;
                SDL_Event event;
                SDL_Texture *textureSauvegarde, *textureSauvegardeReussi, *textureInformation, *textureSauvegarder, *textureBouttonMenuEditeur, *textureMenuPauseEditeur, *textureCarreEditeur, *textureCarreSelectionneEditeur, *textureFlecheMenu, *textureBlack, *textureMenuPause, *textureBouttonPause, *textureVictoire, *textureMario, *textureMenu, *textureCaisse, *textureCaisseOk, *textureMarioBas, *textureMarioHaut, *textureMarioGauche, *textureMarioDroite, *textureMur, *textureObjectif;
                SDL_Rect destinationBoutton2, destinationBoutton3, destinationCarreEditeur, destinationCaisseEditeur, destinationCaisseOkEditeur, destinationMarioEditeur, destinationMurEditeur, destinationObjectifEditeur, destinationFlecheMenu, zoneMenuEditeur, dZME2, dZME3, dZME4, delimitationZoneModifiableEditeur, destinationBouttonsMenuPause, destinationBlack, destinationMenuPause, destinationBouttonPause, destinationVictoire, ancienneDestinationMario, destinationMenu, destinationCaisse, destinationCaisseOk, destinationMario, destinationMur, destinationObjectif;
                SDL_Surface *logo;
                const int DELAI = 8;
                const Uint8 *state = SDL_GetKeyboardState(NULL);
                DataCarreEditeur carreEditeur1, carreEditeur2, carreEditeur3, carreEditeur4, carreEditeur5;
            
                if (SDL_Init(SDL_INIT_VIDEO) < 0)
                    messageError("Erreur d'initialisation", "Impossible d'initialiser la bibliotheque SDL : ");
            
                if (SDL_CreateWindowAndRenderer(0, 0, SDL_WINDOW_MAXIMIZED|SDL_WINDOW_RESIZABLE, &window, &renderer))
                    messageError("Erreur de chargement", "Impossible de charger la fenetre ou le moteur de rendu : ");
            
                SDL_SetWindowTitle(window, "Mario Sokoban - Iconic I Clash");
                logo = IMG_Load("logo.png");
                SDL_SetWindowIcon(window, logo);
                SDL_FreeSurface(logo);
            
                SDL_SetWindowMinimumSize(window, SDL_GetWindowSurface(window)->w, SDL_GetWindowSurface(window)->h);
            
                textureMenu = genererTexture("menu.png", renderer);
                destinationMenu = centrerImage(textureMenu, destinationMenu, window, NULL);
            
                textureFlecheMenu = genererTexture("triangle.png", renderer);
                redimensionner(&destinationFlecheMenu, 38*inverseProportionDimensions(SDL_GetWindowSurface(window)->h/(705/38), SDL_GetWindowSurface(window)->w/(705/38), 38, 38), NULL);
                destinationFlecheMenu.x = destinationMenu.x + 0.23 * destinationMenu.w;
            
                jouer = chargementMenu(renderer, textureMenu, &destinationMenu, textureFlecheMenu, &destinationFlecheMenu, 1);
            
                int hauteurFenetreEditeur = 0.85*SDL_GetWindowSurface(window)->h;
            
                zoneMenuEditeur.y = hauteurFenetreEditeur;
                zoneMenuEditeur.h = SDL_GetWindowSurface(window)->h-hauteurFenetreEditeur;
            
                coteBoutonPause = 42*inverseProportionDimensions(SDL_GetWindowSurface(window)->h/(705/42), SDL_GetWindowSurface(window)->w/(705/42), 42, 42);
                distanceBoutonPause = 18*inverseProportionDimensions(SDL_GetWindowSurface(window)->h/(705/18), SDL_GetWindowSurface(window)->w/(705/18), 18, 18);
            
                textureInformation = genererTexture("information.png", renderer);
                textureSauvegarder = genererTexture("enregistrement.png", renderer);
                textureSauvegarde = textureSauvegarder;
                textureSauvegardeReussi = genererTexture("enregistrementReussi.png", renderer);
            
                textureBouttonPause = genererTexture("pause.png", renderer);
                textureBouttonMenuEditeur = genererTexture("menuEditeur.png", renderer);
                redimensionner(&destinationBouttonPause, coteBoutonPause, NULL);
                destinationBouttonPause.x = SDL_GetWindowSurface(window)->w - coteBoutonPause - distanceBoutonPause;
                destinationBouttonPause.y = distanceBoutonPause;
            
                destinationBoutton2 = destinationBouttonPause;
                destinationBoutton2.x = destinationBouttonPause.x-coteBoutonPause - distanceBoutonPause+ESPACEMENT_BOUTTONS*distanceBoutonPause;
                destinationBoutton3 = destinationBouttonPause;
                destinationBoutton3.x = destinationBoutton2.x-coteBoutonPause - distanceBoutonPause+ESPACEMENT_BOUTTONS*distanceBoutonPause;
            
                textureCaisse = genererTexture("caisse.jpg", renderer);
                textureCaisseOk = genererTexture("caisse_ok.jpg", renderer);
                textureMarioBas = genererTexture("mario_bas.gif", renderer);
                textureMarioHaut = genererTexture("mario_haut.gif", renderer);
                textureMarioGauche = genererTexture("mario_gauche.gif", renderer);
                textureMarioDroite = genererTexture("mario_droite.gif", renderer);
                textureMur = genererTexture("mur.jpg", renderer);
                textureObjectif = genererTexture("objectif.png", renderer);
                textureCarreSelectionneEditeur = genererTexture("carreSelectionne.png", renderer);
            
                textureMenuPause = genererTexture("menu-pause.png", renderer);
                textureMenuPauseEditeur = genererTexture("menuPause.png", renderer);
                destinationMenuPause = centrerImage(textureMenuPause, destinationMenuPause, window, &destinationBouttonsMenuPause);
            
                textureBlack = genererTexture("black.png", renderer);
                SDL_QueryTexture(textureBlack, NULL, NULL, &destinationBlack.w, &destinationBlack.h);
                destinationBlack.x = (SDL_GetWindowSurface(window)->w-destinationBlack.w)/2;
                destinationBlack.y = (SDL_GetWindowSurface(window)->h-destinationBlack.h)/2;
            
                textureVictoire = genererTexture("victoire.png", renderer);
                destinationVictoire = centrerImage(textureVictoire, destinationVictoire, window, NULL);
            
                coteRedimensionne = (SDL_GetWindowSurface(window)->h-hauteurFenetreEditeur)/2;
                redimensionner(&destinationCaisseEditeur, coteRedimensionne, NULL);
                redimensionner(&destinationCaisseOkEditeur, coteRedimensionne, NULL);
                redimensionner(&destinationMarioEditeur, coteRedimensionne, textureMarioBas);
                redimensionner(&destinationMurEditeur, coteRedimensionne, NULL);
                redimensionner(&destinationObjectifEditeur, coteRedimensionne, NULL);
            
                textureCarreEditeur = genererTexture("carre.png", renderer);
                redimensionner(&destinationCarreEditeur, coteRedimensionne*1.5, NULL);
                destinationCarreEditeur.y = hauteurFenetreEditeur + coteRedimensionne*0.5/2;
            
                y = hauteurFenetreEditeur + coteRedimensionne/2;
                destinationCaisseEditeur.y = y;
                destinationCaisseOkEditeur.y = y;
                destinationMarioEditeur.y = hauteurFenetreEditeur + coteRedimensionne - destinationMarioEditeur.h/2;
                destinationMurEditeur.y = y;
                destinationObjectifEditeur.y = y;
            
            
                while (continuer) {
            
                    if (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:
                                        jouer = chargementMenu(renderer, textureMenu, &destinationMenu, textureFlecheMenu, &destinationFlecheMenu, 1);
                                        break;
            
                                    case SDLK_DOWN:
                                        destinationFlecheMenu.y = destinationMenu.y + 0.592 * destinationMenu.h;
                                        jouer = chargementMenu(renderer, textureMenu, &destinationMenu, textureFlecheMenu, &destinationFlecheMenu, 0);
                                        break;
            
                                    case SDLK_RETURN:
            
                                        SDL_SetTextureAlphaMod(textureBlack, 100);
            
                                        if (jouer)
                                        {
                                            coteRedimensionne = COTE*inverseProportionDimensions(SDL_GetWindowSurface(window)->h, SDL_GetWindowSurface(window)->w, COTE*LIGNES, COTE*NB_CASES);
                                            espaceVideW = (SDL_GetWindowSurface(window)->w - coteRedimensionne * NB_CASES)/2.0;
                                            espaceVideH = (SDL_GetWindowSurface(window)->h - coteRedimensionne * LIGNES)/2.0;
            
                                            redimensionner(&destinationCaisse, coteRedimensionne, NULL);
                                            redimensionner(&destinationCaisseOk, coteRedimensionne, NULL);
                                            redimensionner(&destinationMario, coteRedimensionne, textureMarioBas);
                                            redimensionner(&destinationMur, coteRedimensionne, NULL);
                                            redimensionner(&destinationObjectif, coteRedimensionne, NULL);
            
                                            SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
            
                                            continuer = genererPartie(carte, renderer);
                                            marioGenere = 0;
                                            retourMenu = 0;
            
                                            while (continuer) {
            
                                                while(SDL_PollEvent(&event))
                                                {
                                                    retourMenu = appelMenuPause(&event, &continuer, distanceBoutonPause, coteBoutonPause, window, carte, textureMenuPause, &destinationMenuPause, textureMenu, &destinationMenu, textureBlack, &destinationBlack, destinationBouttonsMenuPause, renderer, &marioGenere, textureFlecheMenu, &destinationFlecheMenu, textureSauvegardeReussi, textureSauvegarde, 0);
            
                                                    if (!continuer || retourMenu)
                                                        break;
                                                }
            
                                                if (!continuer || retourMenu)
                                                    break;
            
                                                SDL_RenderClear(renderer);
            
                                                if (!chargerPartie(carte, &marioGenere, espaceVideW, espaceVideH, coteRedimensionne, textureMur, &destinationMur, textureObjectif, &destinationObjectif, NULL, &destinationMario, textureCaisse, &destinationCaisse, textureCaisseOk, &destinationCaisseOk, window, renderer))
                                                {
                                                    SDL_RenderCopy(renderer, textureMarioBas, 0, &destinationMario);
                                                    SDL_RenderCopy(renderer, textureInformation, 0, &destinationBoutton3);
                                                    SDL_RenderCopy(renderer, textureSauvegarde, 0, &destinationBoutton2);
                                                    SDL_RenderCopy(renderer, textureBouttonPause, 0, &destinationBouttonPause);
                                                    SDL_RenderPresent(renderer);
                                                    SDL_Delay(700);
            
                                                    for(i = 0; i < 255; i++)
                                                    {
                                                        SDL_RenderClear(renderer);
            
                                                        chargerPartie(carte, &marioGenere, espaceVideW, espaceVideH, coteRedimensionne, textureMur, &destinationMur, textureObjectif, &destinationObjectif, NULL, &destinationMario, textureCaisse, &destinationCaisse, textureCaisseOk, &destinationCaisseOk, window, renderer);
                                                        SDL_RenderCopy(renderer, textureMarioBas, 0, &destinationMario);
                                                        SDL_RenderCopy(renderer, textureInformation, 0, &destinationBoutton3);
                                                        SDL_RenderCopy(renderer, textureSauvegarde, 0, &destinationBoutton2);
                                                        SDL_RenderCopy(renderer, textureBouttonPause, 0, &destinationBouttonPause);
            
                                                        SDL_SetTextureAlphaMod(textureBlack, i);
                                                        SDL_RenderCopy(renderer, textureBlack, 0, &destinationBlack);
            
                                                        SDL_SetTextureAlphaMod(textureVictoire, i);
                                                        SDL_RenderCopy(renderer, textureVictoire, 0, &destinationVictoire);
                                                        SDL_RenderPresent(renderer);
            
                                                        SDL_Delay(7);
                                                    }
            
                                                    SDL_Delay(2000);
            
                                                    SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
            
                                                    for(i = 254; i > 0; i = i-2)
                                                    {
                                                        SDL_RenderClear(renderer);
                                                        SDL_RenderCopy(renderer, textureMenu, 0, &destinationMenu);
                                                        SDL_RenderCopy(renderer, textureFlecheMenu, 0, &destinationFlecheMenu);
            
                                                        SDL_SetTextureAlphaMod(textureBlack, i);
                                                        SDL_RenderCopy(renderer, textureBlack, 0, &destinationBlack);
            
                                                        SDL_SetTextureAlphaMod(textureVictoire, i);
                                                        SDL_RenderCopy(renderer, textureVictoire, 0, &destinationVictoire);
                                                        SDL_RenderPresent(renderer);
            
                                                        SDL_Delay(1);
                                                    }
            
                                                    break;
                                                }
            
                                                ancienneDestinationMario.x = destinationMario.x;
                                                ancienneDestinationMario.y = destinationMario.y;
            
                                                ligne1 = cadrerNombre((int)((destinationMario.y-1-espaceVideH)/coteRedimensionne), 1);
                                                ligne2 = cadrerNombre((int)((destinationMario.y+destinationMario.h+1-espaceVideH)/coteRedimensionne), 1);
                                                ligne3 = cadrerNombre((int)((destinationMario.y-espaceVideH)/coteRedimensionne), 1);
                                                ligne4 = cadrerNombre((int)((destinationMario.y+destinationMario.h-espaceVideH)/coteRedimensionne), 1);
            
                                                case1 = cadrerNombre((int)((destinationMario.x-espaceVideW)/coteRedimensionne), 0);
                                                case2 = cadrerNombre((int)((destinationMario.x+destinationMario.w-espaceVideW)/coteRedimensionne), 0);
                                                case3 = cadrerNombre((int)((destinationMario.x-1-espaceVideW)/coteRedimensionne), 0);
                                                case4 = cadrerNombre((int)((destinationMario.x+destinationMario.w+1-espaceVideW)/coteRedimensionne), 0);
            
                                                if (state[SDL_SCANCODE_UP] && destinationMario.y-1 >= 0 && deplacerJoueur(UP, carte, ligne1, case1, ligne1, case2))
                                                    destinationMario.y -= 1;
                                                if (state[SDL_SCANCODE_DOWN] && destinationMario.y+destinationMario.h-1 <= SDL_GetWindowSurface(window)->h && deplacerJoueur(DOWN, carte, ligne2, case1, ligne2, case2))
                                                    destinationMario.y += 1;
                                                if (state[SDL_SCANCODE_LEFT] && destinationMario.x-1 >= 0  && deplacerJoueur(LEFT, carte, ligne3, case3, ligne4, case3))
                                                    destinationMario.x -= 1;
                                                if (state[SDL_SCANCODE_RIGHT] && destinationMario.x+destinationMario.w-1 <= SDL_GetWindowSurface(window)->w && deplacerJoueur(RIGHT, carte, ligne3, case4, ligne4, case4))
                                                    destinationMario.x += 1;
            
                                                if (!ancienneDestinationMario.x-destinationMario.x && ancienneDestinationMario.y-destinationMario.y == 1)
                                                    textureMario = textureMarioHaut;
                                                else if (ancienneDestinationMario.x-destinationMario.x == 1 && (ancienneDestinationMario.y-destinationMario.y || !ancienneDestinationMario.y-destinationMario.y))
                                                    textureMario = textureMarioGauche;
                                                else if (ancienneDestinationMario.x-destinationMario.x == -1 && (ancienneDestinationMario.y-destinationMario.y || !ancienneDestinationMario.y-destinationMario.y))
                                                    textureMario = textureMarioDroite;
                                                else
                                                    textureMario = textureMarioBas;
            
                                                if(ancienneDestinationMario.x-destinationMario.x != 0 || destinationMario.y-destinationMario.y != 0)
                                                    textureSauvegarde = textureSauvegarder;
            
                                                SDL_RenderCopy(renderer, textureMario, 0, &destinationMario);
                                                SDL_RenderCopy(renderer, textureInformation, 0, &destinationBoutton3);
                                                SDL_RenderCopy(renderer, textureSauvegarde, 0, &destinationBoutton2);
                                                SDL_RenderCopy(renderer, textureBouttonPause, 0, &destinationBouttonPause);
            
                                                SDL_RenderPresent(renderer);
                                                SDL_Delay(tempsAttente);
            
                                                if (ancienneDestinationMario.x-destinationMario.x != 0 && destinationMario.y-destinationMario.y != 0)
                                                    tempsAttente = DELAI*sqrt(2);
                                                else
                                                    tempsAttente = DELAI;
                                            }
                                        }
                                        else
                                        {
                                            //solution temporaire au bug B-2021-12-8920 concernant la condition if(0) ne marchant pas après avoir quitté un mode choisi
                                            SDL_Delay(200);
            
                                            coteRedimensionne = COTE*inverseProportionDimensions(hauteurFenetreEditeur, SDL_GetWindowSurface(window)->w, COTE*LIGNES, COTE*NB_CASES);
                                            espaceVideW = (SDL_GetWindowSurface(window)->w - coteRedimensionne * NB_CASES)/2.0;
                                            espaceVideH = (hauteurFenetreEditeur - coteRedimensionne * LIGNES)/2.0;
            
                                            destinationMurEditeur.x = espaceVideW + 0.175*SDL_GetWindowSurface(window)->w;
                                            destinationMarioEditeur.x = (SDL_GetWindowSurface(window)->w-destinationMarioEditeur.w)/2;
                                            destinationObjectifEditeur.x = (destinationMarioEditeur.x + destinationMurEditeur.x)/2;
                                            destinationCaisseOkEditeur.x = SDL_GetWindowSurface(window)->w - (espaceVideW + destinationCaisseOkEditeur.w) - 0.175*SDL_GetWindowSurface(window)->w;
                                            destinationCaisseEditeur.x = (destinationMarioEditeur.x + destinationCaisseOkEditeur.x)/2;
            
                                            zoneMenuEditeur.x = 0+espaceVideW;
                                            zoneMenuEditeur.w = SDL_GetWindowSurface(window)->w-espaceVideW*2;
            
                                            redimensionner(&destinationCaisse, coteRedimensionne, NULL);
                                            redimensionner(&destinationCaisseOk, coteRedimensionne, NULL);
                                            redimensionner(&destinationMario, coteRedimensionne, textureMarioBas);
                                            redimensionner(&destinationMur, coteRedimensionne, NULL);
                                            redimensionner(&destinationObjectif, coteRedimensionne, NULL);
            
                                            carreEditeur1.x = destinationMurEditeur.x + (destinationMurEditeur.w - destinationCarreEditeur.w)/2;
                                            carreEditeur2.x = destinationObjectifEditeur.x + (destinationObjectifEditeur.w - destinationCarreEditeur.w)/2;
                                            carreEditeur3.x = destinationMarioEditeur.x + (destinationMarioEditeur.w - destinationCarreEditeur.w)/2;
                                            carreEditeur4.x = destinationCaisseEditeur.x + (destinationCaisseEditeur.w - destinationCarreEditeur.w)/2;
                                            carreEditeur5.x = destinationCaisseOkEditeur.x + (destinationCaisseOkEditeur.w - destinationCarreEditeur.w)/2;
            
                                            modifierCarreEditeur(&carreEditeur1, &carreEditeur2, &carreEditeur3, &carreEditeur4, &carreEditeur5, textureCarreEditeur, textureCarreSelectionneEditeur);
                                            reinitialiser(carte);
            
                                            delimitationZoneModifiableEditeur.x = espaceVideW;
                                            delimitationZoneModifiableEditeur.y = espaceVideH;
                                            delimitationZoneModifiableEditeur.w = coteRedimensionne * NB_CASES;
                                            delimitationZoneModifiableEditeur.h = coteRedimensionne * LIGNES;
            
                                            dZME2 = rectangleCouleurs(delimitationZoneModifiableEditeur, 1, coteRedimensionne, espaceVideH, espaceVideW);
                                            dZME3 = rectangleCouleurs(delimitationZoneModifiableEditeur, 2, coteRedimensionne, espaceVideH, espaceVideW);
                                            dZME4 = rectangleCouleurs(delimitationZoneModifiableEditeur, 3, coteRedimensionne, espaceVideH, espaceVideW);
            
                                            r = 245;
                                            g = 215;
                                            b = 177;
            
                                            boucleCroissante = 1;
                                            tempsPrecedent = 0;
                                            marioGenere = 0;
                                            ajouterMur = 0;
                                            ajouter = 0;
                                            effacer = 0;
            
                                            while (continuer)
                                            {
                                                while(SDL_PollEvent(&event))
                                                {
                                                    if (event.type == SDL_QUIT || event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_ESCAPE)
                                                    {
                                                        continuer = 0;
                                                        break;
                                                    }
            
                                                    if(event.type == SDL_MOUSEBUTTONDOWN)
                                                    {
                                                        if (event.button.button == SDL_BUTTON_LEFT && !effacer)
                                                        {
                                                            ligne1 = (event.button.y-espaceVideH)/coteRedimensionne;
                                                            case1 = (event.button.x-espaceVideW)/coteRedimensionne;
            
                                                            if (event.button.y - destinationCarreEditeur.y >= 0 && event.button.y <= destinationCarreEditeur.y + destinationCarreEditeur.h)
                                                            {
                                                                if (event.button.x - carreEditeur1.x >= 0 && event.button.x <= carreEditeur1.x + destinationCarreEditeur.w)
                                                                {
                                                                    carreEditeur1.texture = modifierCarreEditeur(&carreEditeur1, &carreEditeur2, &carreEditeur3, &carreEditeur4, &carreEditeur5, textureCarreEditeur, textureCarreSelectionneEditeur);
                                                                    ajouter = 1;
                                                                }
            
                                                                if (event.button.x - carreEditeur2.x >= 0 && event.button.x <= carreEditeur2.x + destinationCarreEditeur.w)
                                                                {
                                                                    carreEditeur2.texture = modifierCarreEditeur(&carreEditeur1, &carreEditeur2, &carreEditeur3, &carreEditeur4, &carreEditeur5, textureCarreEditeur, textureCarreSelectionneEditeur);
                                                                    ajouter = 2;
                                                                }
            
                                                                if (event.button.x - carreEditeur3.x >= 0 && event.button.x <= carreEditeur3.x + destinationCarreEditeur.w)
                                                                {
                                                                    if (!marioGenere)
                                                                        carreEditeur3.texture = modifierCarreEditeur(&carreEditeur1, &carreEditeur2, &carreEditeur3, &carreEditeur4, &carreEditeur5, textureCarreEditeur, textureCarreSelectionneEditeur);
                                                                    else
                                                                        modifierCarreEditeur(&carreEditeur1, &carreEditeur2, &carreEditeur3, &carreEditeur4, &carreEditeur5, textureCarreEditeur, textureCarreSelectionneEditeur);
            
                                                                    ajouter = 3;
                                                                }
            
                                                                if (event.button.x - carreEditeur4.x >= 0 && event.button.x <= carreEditeur4.x + destinationCarreEditeur.w)
                                                                {
                                                                    carreEditeur4.texture = modifierCarreEditeur(&carreEditeur1, &carreEditeur2, &carreEditeur3, &carreEditeur4, &carreEditeur5, textureCarreEditeur, textureCarreSelectionneEditeur);
                                                                    ajouter = 4;
                                                                }
            
                                                                if (event.button.x - carreEditeur5.x >= 0 && event.button.x <= carreEditeur5.x + destinationCarreEditeur.w)
                                                                {
                                                                    carreEditeur5.texture = modifierCarreEditeur(&carreEditeur1, &carreEditeur2, &carreEditeur3, &carreEditeur4, &carreEditeur5, textureCarreEditeur, textureCarreSelectionneEditeur);
                                                                    ajouter = 5;
                                                                }
                                                            }
                                                            else
                                                            {
                                                                if (ligne1 >= 0 && ligne1 < LIGNES && case1 >= 0 && case1 < NB_CASES)
                                                                {
                                                                    if (ajouter == 3)
                                                                    {
                                                                        if (!marioGenere)
                                                                        {
                                                                            marioGenere = 1;
                                                                            carte[ligne1][case1] = ajouter;
                                                                        }
                                                                        carreEditeur3.texture = textureCarreEditeur;
                                                                    }
            
                                                                    if (ajouter != 0 && ajouter != 3)
                                                                        carte[ligne1][case1] = ajouter;
            
                                                                    if(ajouter != 0)
                                                                        textureSauvegarde = textureSauvegarder;
            
                                                                    if (ajouter == 1)
                                                                        ajouterMur = 1;
                                                                }
                                                            }
                                                        }
            
                                                        if (event.button.button == SDL_BUTTON_RIGHT && !ajouterMur)
                                                        {
                                                            effacer = 1;
                                                            ligne1 = cadrerNombre((int)((event.button.y-espaceVideH)/coteRedimensionne), 1);
                                                            case1 = cadrerNombre((int)((event.button.x-espaceVideW)/coteRedimensionne), 0);
            
                                                            if (carte[ligne1][case1] == 3)
                                                            {
                                                                marioGenere = 0;
            
                                                                if (ajouter == 3)
                                                                    carreEditeur3.texture = textureCarreSelectionneEditeur;
                                                            }
            
                                                            carte[ligne1][case1] = 0;
                                                        }
                                                    }
            
                                                    if(event.type == SDL_MOUSEBUTTONUP)
                                                    {
                                                        if (effacer && event.button.button == SDL_BUTTON_RIGHT)
                                                            effacer = 0;
            
                                                        if (ajouterMur && event.button.button == SDL_BUTTON_LEFT)
                                                            ajouterMur = 0;
                                                    }
            
                                                    if (event.type == SDL_MOUSEMOTION)
                                                    {
                                                        ligne1 = cadrerNombre((int)((event.motion.y-espaceVideH)/coteRedimensionne), 1);
                                                        case1 = cadrerNombre((int)((event.motion.x-espaceVideW)/coteRedimensionne), 0);
            
                                                        if (effacer)
                                                        {
                                                            if (carte[ligne1][case1] == 3)
                                                            {
                                                                marioGenere = 0;
            
                                                                if (ajouter == 3)
                                                                    carreEditeur3.texture = textureCarreSelectionneEditeur;
                                                            }
                                                            carte[ligne1][case1] = 0;
                                                        }
            
                                                        if(ajouterMur)
                                                            carte[ligne1][case1] = 1;
                                                    }
            
                                                    retourMenu = appelMenuPause(&event, &continuer, distanceBoutonPause, coteBoutonPause, window, carte, textureMenuPauseEditeur, &destinationMenuPause, textureMenu, &destinationMenu, textureBlack, &destinationBlack, destinationBouttonsMenuPause, renderer, &marioGenere, textureFlecheMenu, &destinationFlecheMenu, textureSauvegardeReussi, textureSauvegarde, 1);
            
                                                    if (!continuer || retourMenu)
                                                        break;
                                                }
            
                                                if (!continuer || retourMenu)
                                                    break;
            
                                                SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
                                                SDL_RenderClear(renderer);
            
                                                chargerPartie(carte, NULL, espaceVideW, espaceVideH, coteRedimensionne, textureMur, &destinationMur, textureObjectif, &destinationObjectif, textureMarioBas, &destinationMario, textureCaisse, &destinationCaisse, textureCaisseOk, &destinationCaisseOk, window, renderer);
            
                                                tempsActuel = SDL_GetTicks();
            
                                                if (tempsActuel - tempsPrecedent > 70)
                                                {
                                                    r = animationCouleurs(r, &boucleCroissante);
                                                    g = animationCouleurs(g, &boucleCroissante);
                                                    b = animationCouleurs(b, &boucleCroissante);
            
                                                    tempsPrecedent = tempsActuel;
                                                }
            
                                                SDL_SetRenderDrawColor(renderer, r, g, b, 255);
            
                                                SDL_RenderDrawRect(renderer, &delimitationZoneModifiableEditeur);
                                                SDL_RenderDrawRect(renderer, &dZME2);
                                                SDL_RenderDrawRect(renderer, &dZME3);
                                                SDL_RenderDrawRect(renderer, &dZME4);
            
                                                SDL_SetRenderDrawColor(renderer, 255, 248, 240, 255);
                                                SDL_RenderFillRect(renderer, &zoneMenuEditeur);
            
                                                for(i = 0; i < espaceVideW+1; i++)
                                                {
                                                    SDL_SetRenderDrawColor(renderer, 255-((255-242)*i/(espaceVideW+1)), 248-((248-212)*i/(espaceVideW+1)), 240-((240-170)*i/(espaceVideW+1)), 255);
                                                    SDL_RenderDrawLine(renderer, espaceVideW-i, hauteurFenetreEditeur, espaceVideW-i, SDL_GetWindowSurface(window)->h);
                                                    SDL_RenderDrawLine(renderer, SDL_GetWindowSurface(window)->w-espaceVideW+i, hauteurFenetreEditeur, SDL_GetWindowSurface(window)->w-espaceVideW+i, SDL_GetWindowSurface(window)->h);
                                                }
            
                                                copierCarreEditeur(carreEditeur1, &destinationCarreEditeur, renderer);
                                                copierCarreEditeur(carreEditeur2, &destinationCarreEditeur, renderer);
                                                copierCarreEditeur(carreEditeur3, &destinationCarreEditeur, renderer);
                                                copierCarreEditeur(carreEditeur4, &destinationCarreEditeur, renderer);
                                                copierCarreEditeur(carreEditeur5, &destinationCarreEditeur, renderer);
            
                                                SDL_RenderCopy(renderer, textureMur, 0, &destinationMurEditeur);
                                                SDL_RenderCopy(renderer, textureMarioBas, 0, &destinationMarioEditeur);
                                                SDL_RenderCopy(renderer, textureObjectif, 0, &destinationObjectifEditeur);
                                                SDL_RenderCopy(renderer, textureCaisseOk, 0, &destinationCaisseOkEditeur);
                                                SDL_RenderCopy(renderer, textureCaisse, 0, &destinationCaisseEditeur);
            
                                                SDL_RenderCopy(renderer, textureInformation, 0, &destinationBoutton3);
                                                SDL_RenderCopy(renderer, textureSauvegarde, 0, &destinationBoutton2);
                                                SDL_RenderCopy(renderer, textureBouttonMenuEditeur, 0, &destinationBouttonPause);
                                                SDL_RenderPresent(renderer);
            
                                                if (!effacer && !ajouterMur)
                                                    SDL_Delay(10);
                                                else
                                                    SDL_Delay(1);
                                            }
                                        }
            
                                        if (continuer)
                                            jouer = chargementMenu(renderer, textureMenu, &destinationMenu, textureFlecheMenu, &destinationFlecheMenu, 2);
                                        break;
                                }
                                break;
                        }
                    }
                }
            
                SDL_DestroyTexture(textureSauvegarde);
                SDL_DestroyTexture(textureSauvegardeReussi);
                SDL_DestroyTexture(textureSauvegarder);
                SDL_DestroyTexture(textureInformation);
                SDL_DestroyTexture(textureCarreEditeur);
                SDL_DestroyTexture(textureCarreSelectionneEditeur);
                SDL_DestroyTexture(textureFlecheMenu);
                SDL_DestroyTexture(textureBlack);
                SDL_DestroyTexture(textureBouttonPause);
                SDL_DestroyTexture(textureMenu);
                SDL_DestroyTexture(textureCaisse);
                SDL_DestroyTexture(textureCaisseOk);
                SDL_DestroyTexture(textureMarioBas);
                SDL_DestroyTexture(textureMarioHaut);
                SDL_DestroyTexture(textureMarioGauche);
                SDL_DestroyTexture(textureMarioDroite);
                SDL_DestroyTexture(textureMario);
                SDL_DestroyTexture(textureVictoire);
                SDL_DestroyTexture(textureMur);
                SDL_DestroyTexture(textureObjectif);
            
                SDL_DestroyRenderer(renderer);
                SDL_DestroyWindow(window);
                SDL_Quit();
            
                return EXIT_SUCCESS;
            }



            Comme code illisible, c'est pas mal. Il faut faire des fonctions.

            Et les variables machin1 machin2 machin3 et machin4, tu peux les mettre dans un tableau.

            De même (je n'ai pas vraiment regardé), je suppose que tu peux regrouper des variables dans une structure.

            -
            Edité par edgarjacobs 22 décembre 2021 à 23:23:51

            • Partager sur Facebook
            • Partager sur Twitter

            Il y a ceux qui font des sauvegardes, et ceux qui n'ont pas encore eu d'incident....

              23 décembre 2021 à 8:39:43

              Iconic I Clash a écrit:

              Salut,

              Merci pour vos réponses.

              @markand, pourquoi est-ce que ma fonction main est scandaleuse ?


              @edgarjacobs a à peu près tout dit. si tu ne remarques pas de toi même ce qui ne va pas dans ta fonction il faut que tu continues de lire des cours et de regarder des projets opensource pour t'inspirer. Il y a aussi :

              • Beaucoup trop d'indentation
              • Aucun design de données (j'ai pas trouvé une seule structure, union ou énumération dans ton code)
              • Partager sur Facebook
              • Partager sur Twitter

              l'azerty est aux dispositions ce que subversion est aux SCM

                8 janvier 2022 à 23:33:02

                Salut,

                J'ai mis à jour mon code, qui est beaucoup plus propre, sur Github, mais je n'ai pas fini mon jeu.

                Bon, comme je suis un gros flemmard, je n'ai pas traduis mon code en Anglais.

                Le bug pour la texture de la sauvegarde a magiquement disparu et celui pour la condition avec la variable jouer vient d'un bug de SDL2 avec le SDLK_RETURN.

                Je l'ai remplacé avec SDLK_1 et tout marche correctement.

                Problème : je voudrais vraiment pouvoir détecter la touche entrée.

                Et aussi, dans l'animation de fin de partie, lorsque l'on fait un clique alors que la boucle diminuant la transparence de l'image de victoire, l'image se fige.

                Comment faire ?

                Merci

                -
                Edité par Iconic I Clash 8 janvier 2022 à 23:36:02

                • Partager sur Facebook
                • Partager sur Twitter
                  8 janvier 2022 à 23:39:50

                  Iconic I Clash a écrit:

                  Le bug (....) pour la condition avec la variable jouer vient d'un bug de SDL2 avec le SDLK_RETURN.

                  (....)

                  Problème : je voudrais vraiment pouvoir détecter la touche entrée.

                  Il y a 2 valeurs de retour différentes: SDLK_RETURN qui est la touche <═╝ du clavier alphabétique, et SDLK_KP_ENTER qui est la touche ENTER du pavé numérique. Ce n'est pas sdl qui a un problème.

                  Iconic I Clash a écrit:

                  (....) Le bug pour la texture de la sauvegarde a magiquement disparu (....)

                  Ça n'annonce rien de bon....

                  -
                  Edité par edgarjacobs 8 janvier 2022 à 23:52:06

                  • Partager sur Facebook
                  • Partager sur Twitter

                  Il y a ceux qui font des sauvegardes, et ceux qui n'ont pas encore eu d'incident....

                    9 janvier 2022 à 10:24:01

                    J'ai bien utilisé SDLK_RETURN pour la touche entrée du clavier alphabétique.

                    Lorsque qu'il y a une condition, pour exécuter le code qui suit, le else de if(0) fonctionne une fois puis aléatoirement.

                    Sinon, c'est le code qui suit est également exécuter une fois puis aléatoirement.

                    En tout cas, j'ai essayé de débugger au maximum mon code, supprimer toutes les lignes qui pouvaient encore être supprimé sans gêner mes tests et j'en ai conclus que SDLK_RETURN faisait bugger mon programme.

                    EDIT : c'est pareil si je fais SDL_GetKeyboardState(NULL)[SDL_SCANCODE_RETURN] mais tout marche très bien avec les autres touches.

                    -
                    Edité par Iconic I Clash 9 janvier 2022 à 10:53:56

                    • Partager sur Facebook
                    • Partager sur Twitter
                      9 janvier 2022 à 16:48:47

                      Ce petit code pour te montrer que sdl2 n'a pas le bug que tu prétends lui donner 
                      #include <stdio.h>
                      #include <sdl2/sdl.h>
                      
                      int main(int argc,char *argv[]) {
                      	SDL_Init(SDL_INIT_VIDEO);
                      	SDL_Window *wnd=SDL_CreateWindow("",SDL_WINDOWPOS_CENTERED,SDL_WINDOWPOS_CENTERED,100,40,SDL_WINDOW_SHOWN);
                      	SDL_Renderer *rdr=SDL_CreateRenderer(wnd,-1,SDL_RENDERER_ACCELERATED);
                      	SDL_SetRenderDrawColor(rdr,250,250,250,SDL_ALPHA_OPAQUE);
                      	SDL_RenderClear(rdr);
                      	SDL_RenderPresent(rdr);
                      
                      	while(1) {
                      		SDL_Event event;
                      		SDL_WaitEvent(&event);
                      		if(event.type==SDL_KEYUP) {
                      			if(event.key.keysym.sym==SDLK_ESCAPE)
                      				break;
                      			if(event.key.keysym.sym==SDLK_RETURN)
                      				puts("enter keyb alpha");
                      			if(event.key.keysym.sym==SDLK_KP_ENTER)
                      				puts("enter keypad");
                      		}
                      	}
                      
                      	SDL_DestroyRenderer(rdr);
                      	SDL_DestroyWindow(wnd);
                      	SDL_Quit();
                      	
                      	return(0);
                      }
                      


                      Quand on a un programme qui exécute aléatoirement du code, du code qui s'exécute une fois puis plus, et dont un bug disparait miraculeusement, il est nécessaire de se poser des questions sur le programme en question, avant de croire que c'est la lib qui déconne, surtout quand cette lib est pas mal utilisée, et ce depuis des années. Evidemment, incriminer une lib permet de ne pas remettre en question la qualité du programme qui l'utilise.

                      Edit: j'ai voulu aller chercher ton programme, mais le lien est mort.

                      -
                      Edité par edgarjacobs 9 janvier 2022 à 16:58:54

                      • Partager sur Facebook
                      • Partager sur Twitter

                      Il y a ceux qui font des sauvegardes, et ceux qui n'ont pas encore eu d'incident....

                        9 janvier 2022 à 18:20:00

                        Ah, oui, ça fonctionne correctement.

                        Je vais continuer à chercher. J'ai mis à jour le lien.

                        Merci

                        • Partager sur Facebook
                        • Partager sur Twitter
                          9 janvier 2022 à 20:38:37

                          Je reconnais que tu as fait un effort, mais....

                          Dans ton main, encore des pelletées de variables déclarées, 250 lignes dont certaines dépassent les 250 caractères, des fonctions qui prennent 20 arguments.... c'est un code impossible à lire et comprendre.

                          Je suis certain que le main() n'a pas à passer toutes ces variables aux fonctions, elles peuvent elles-même les déduire ou les cacluler.

                          -
                          Edité par edgarjacobs 9 janvier 2022 à 20:38:55

                          • Partager sur Facebook
                          • Partager sur Twitter

                          Il y a ceux qui font des sauvegardes, et ceux qui n'ont pas encore eu d'incident....

                          [MARIO SOKOBAN] 2 bugs : texture et condition

                          × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                          • Editeur
                          • Markdown