Partage
  • Partager sur Facebook
  • Partager sur Twitter

Besoin d'un (second) petit coup de main

SDL_BlitSurface (2ème paramètre)

Sujet résolu
    10 juin 2007 à 9:39:59

    Bonjour,

    Vous avez résolu, il y a deux jours je crois mon probleme qui était un bete oubli de libération de surface. (A savoir, c'est ici :))

    Aujourd'hui je suis toujours sur le meme projet (un petit jeu en SDL) et j'ai besoin d'utiliser le deuxième paramètre de la fonction "SDL_BlitSurface". Comme vous le savez très certainement, c'est un SDL_Rect concernant la partie à blitter.

    Jusqu'ici tout allait bien, la fonction faisait ce que je lui demandait. Mais maintenant le menu de mon jeu me permet de me rendre sur 2 parties différentes (utilisant 2 fonds différents). Dans les 2 cas j'utilise ce 2ème paramètre de la fonction de Blit. J'ai donc du aussi utiliser 2 SDL_Rect différents.

    Le problème : quand le premier fond fonctionne correctement, le 2ème ne va pas et vice-versa. Celui ne fonctionnant pas est coupé comme si je mettait (en 2ème paramètre) un SDL_Rect avec x = 0 et y = 500 je dirais !

    Quelqu'un pourrait-il m'en dire un peu plus sur ce deuxième paramètre ?


    Merci d'avance.
    • Partager sur Facebook
    • Partager sur Twitter
      10 juin 2007 à 10:15:43

      Salut,

      C'est le forum C++ ici, tu programmes vraiment en C++ ?
      Enfin, C++ ou non, sans code source on peut pas trop t'aider.

      http://www.siteduzero.com/forum-83-154296-1404353.html#r1404353
      http://www.libsdl.org/cgi/docwiki.cgi/SDL_5fBlitSurface
      • Partager sur Facebook
      • Partager sur Twitter
        10 juin 2007 à 10:23:26

        Salut, oui je programme en C++. De plus ces blit se trouve à l'intérieur de méthodes d'un class appelée "Fenetre".

        Dans ton premier lien, il est expliqué ce que je demande et c'est exactement comment je l'ai utilisée.
        De plus, c'est meme pour la meme raison faire défiler une map plus grande que l'écran. Et ca marchait parfaitement ! Mais depuis que j'ai rajouté un deuxième fond pour une partie editeur en plus de la partie jeu, la fonction se comporte très bizarrement.

        J'enverrai le code dès que possible...
        • Partager sur Facebook
        • Partager sur Twitter
          10 juin 2007 à 10:56:32

          A mon avis tu as fais une erreur dans la 138 eme ligne de fichier pilypily.cc

          Voili Voilou


          ( A mon avis avec un code ça sera plus simple ^^ )
          • Partager sur Facebook
          • Partager sur Twitter
            10 juin 2007 à 11:29:26

            Bon je vous envoie du code !^^
            J'ai repéré l'erreur mais veuillez lire la partie erreur au bas de ce message svp, je ne comprends pas


            main.cpp
            #include "createur.hpp"
            #include "Heros.hpp"
            #include "Fenetre.hpp"
            #include "jeu.hpp"
            #include <string>
            #include "editeur.hpp"
            using namespace std;

            int main(int argc, char *argv[])
            {
                preparation();

                SDL_Event event;
                bool power = true;

                SDL_Init(SDL_INIT_VIDEO);
                TTF_Init();

                Fenetre fenetre;

                while(power)
                {
                    SDL_WaitEvent(&event);

                    switch(event.type)
                    {
                        case SDL_QUIT: power = false;
                        break;
                        case SDL_KEYUP: switch(event.key.keysym.sym)
                                        {
                                            case SDLK_KP1: jeu(fenetre);
                                            break;
                                            case SDLK_KP2: editeur(fenetre);
                                            break;
                                        }
                        break;
                    }

                    fenetre.afficherMenu();

                    fenetre.miseAJour();
                }


                TTF_Quit();
                SDL_Quit();

                return EXIT_SUCCESS;
            }



            Jeu.cpp
            #include <iostream>
            #include <SDL/SDL.h>
            #include <SDL/SDL_image.h>
            #include <SDL/SDL_ttf.h>
            #include <FMOD/fmod.h>
            #include "constantes.hpp"
            #include "createur.hpp"
            #include "Heros.hpp"
            #include "Fenetre.hpp"
            #include <string>

            using namespace std;

            void jeu(Fenetre& fenetre)
            {
                SDL_Event event;
                bool jeu = true;

                Heros gimralas;

                fenetre.afficherFond();
                    gimralas.afficherImage(fenetre);
                    if(fenetre.getAfficherVie())
                    {
                        gimralas.afficherVie(fenetre);
                    }
                fenetre.miseAJour();


                SDL_EnableKeyRepeat(10, 70);

                while(jeu)
                {
                    SDL_WaitEvent(&event);

                    switch(event.type)
                    {
                        case SDL_QUIT: jeu = false;
                        break;
                        case SDL_KEYDOWN:   switch(event.key.keysym.sym)
                                            {
                                                case SDLK_RIGHT: gimralas.deplacer(AVANT, fenetre);
                                                break;
                                                case SDLK_LEFT: gimralas.deplacer(ARRIERE, fenetre);
                                                break;
                                                case SDLK_v: fenetre.setAfficherVie();
                                                break;
                                            }
                        break;
                        case SDL_KEYUP: switch(event.key.keysym.sym)
                                        {
                                            case SDLK_RIGHT: gimralas.setMove();
                                            break;
                                            case SDLK_LEFT: gimralas.setMove();
                                            break;
                                            case SDLK_SPACE: gimralas.sauter(fenetre);
                                            break;
                                            case SDLK_ESCAPE: jeu = false;
                                            break;
                                        }
                        break;
                    }

                    fenetre.afficherFond();
                    gimralas.afficherImage(fenetre);
                    if(fenetre.getAfficherVie())
                    {
                        gimralas.afficherVie(fenetre);
                    }

                    fenetre.miseAJour();
                }
            }



            editeur.cpp
            #include <iostream>
            #include <SDL/SDL.h>
            #include <SDL/SDL_image.h>
            #include <SDL/SDL_ttf.h>
            #include "constantes.hpp"
            #include "createur.hpp"
            #include "Heros.hpp"
            #include "Fenetre.hpp"
            #include <string>

            void editeur(Fenetre& fenetre)
            {
                SDL_Event event;
                bool editeur = true;

                fenetre.effacerEcran();
                fenetre.miseAJour();


                bool ecriture = false;
                bool optionR = false, optionV = false, optionB = false;
                long taille = 2;
                long r = 0, v = 0, b = 0;
                bool afficherOption = false;

                SDL_EnableKeyRepeat(100, 10);

                while(editeur)
                {
                    SDL_WaitEvent(&event);

                    switch(event.type)
                    {
                        case SDL_QUIT: editeur = false;
                        break;
                        case SDL_MOUSEBUTTONDOWN:   switch(event.button.button)
                                                    {
                                                        case SDL_BUTTON_LEFT: ecriture = true;
                                                        break;
                                                    }
                        break;
                        case SDL_MOUSEBUTTONUP: switch(event.button.button)
                                                {
                                                    case SDL_BUTTON_LEFT: ecriture = false;
                                                    break;
                                                }
                        break;
                        case SDL_MOUSEMOTION:   if(ecriture)
                                                {
                                                    fenetre.coloriage(event.motion.x, event.motion.y, taille, r, v, b);
                                                }
                        break;
                        case SDL_KEYUP: switch(event.key.keysym.sym)
                                        {
                                            case SDLK_ESCAPE: editeur = false;
                                            break;
                                            case SDLK_r: optionR = false;
                                            break;
                                            case SDLK_v: optionV = false;
                                            break;
                                            case SDLK_b: optionB = false;
                                            break;
                                            case SDLK_o: if(afficherOption){afficherOption=false;} else{afficherOption=true;}
                                            break;
                                        }
                        break;
                        case SDL_KEYDOWN:   switch(event.key.keysym.sym)
                                            {
                                                case SDLK_UP: taille++; if(taille > 100){taille = 100;}
                                                break;
                                                case SDLK_DOWN: taille--; if(taille < 2){taille = 2;}
                                                break;
                                                case SDLK_RIGHT: if(optionR){r++;} else if(optionV){v++;} else if (optionB){b++;}
                                                                 if(r > 255){r=255;} if(v > 255){v=255;} if(b > 255){b=255;}
                                                break;
                                                case SDLK_LEFT: if(optionR){r--;} else if(optionV){v--;} else if (optionB){b--;}
                                                                 if(r < 0){r=0;} if(v < 0){v=0;} if(b < 0){b=0;}
                                                break;
                                                case SDLK_r: optionR = true;
                                                break;
                                                case SDLK_v: optionV = true;
                                                break;
                                                case SDLK_b: optionB = true;
                                                break;
                                            }
                        break;
                    }

                    fenetre.afficherEditeur();
                    if (afficherOption)
                    {
                        fenetre.afficherOption(taille, r, v, b);
                    }
                    fenetre.miseAJour();
                }
            }


            Fenetre.hpp
            #ifndef DEF_C_FENETRE
            #define DEF_C_FENETRE

                #include <iostream>
                #include <SDL/SDL.h>
                #include <SDL/SDL_image.h>
                #include <SDL/SDL_ttf.h>
                #include <FMOD/fmod.h>
                #include "constantes.hpp"
                #include "createur.hpp"
                #include "Heros.hpp"

                class Fenetre
                {
                    private:

                    SDL_Surface* m_ecran;
                    SDL_Surface* m_fond;
                    SDL_Surface* m_editeur;
                    SDL_Rect m_positionFond;
                    bool m_afficherVie;
                    SDL_Surface* m_menu;
                    SDL_Rect m_positionMenu;
                    SDL_Rect m_partieFond;
                    SDL_Rect m_positionEditeur;
                    SDL_Rect m_partieEditeur;


                    public:

                    Fenetre();
                    ~Fenetre();
                    void afficherFond();
                    void miseAJour();
                    SDL_Surface* getEcran();
                    void setAfficherVie();
                    bool getAfficherVie();
                    void setFond(bool avant, long nombre = 12);
                    void afficherMenu();
                    void effacerEcran();
                    void coloriage(long, long, long, long r = 0, long v = 0, long b = 0);
                    void afficherEditeur();
                    void afficherOption(long, long, long, long);
                };

            #endif



            Fenetre.cpp
            #include <iostream>
            #include <SDL/SDL.h>
            #include <SDL/SDL_image.h>
            #include <SDL/SDL_ttf.h>
            #include <FMOD/fmod.h>
            #include "constantes.hpp"
            #include "createur.hpp"
            #include "Heros.hpp"
            #include "Fenetre.hpp"
            #include <string>
            using namespace std;

            Fenetre::Fenetre() : m_afficherVie(true)
            {
                SDL_WM_SetIcon(IMG_Load("images/icone.png"), NULL);
                m_ecran = SDL_SetVideoMode(LARGEUR_F, HAUTEUR_F, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);
                SDL_FillRect(m_ecran, NULL, SDL_MapRGB(m_ecran->format, 255, 255, 255));
                SDL_WM_SetCaption("Aventure de Gimralas", NULL);

                m_fond = SDL_CreateRGBSurface(SDL_HWSURFACE, LARGEUR_F * 2, HAUTEUR_F, 32, 0, 0, 0, 0);
                createurPaysage(m_ecran, m_fond);

                m_editeur = SDL_CreateRGBSurface(SDL_HWSURFACE, LARGEUR_F * 2, HAUTEUR_F, 32, 0, 0, 0, 0);
                SDL_FillRect(m_editeur, NULL, SDL_MapRGB(m_ecran->format, 255, 255, 255));

                m_menu = IMG_Load("images/menu.png");

                m_positionFond.x = 0;
                m_positionFond.y = 0;
                m_positionMenu.x = 0;
                m_positionMenu.y = 0;
                m_partieFond.x = 0;
                m_partieFond.y = 0;
                m_positionEditeur.x = 0;
                m_positionEditeur.y = 0;
                m_partieEditeur.x = 0;
                m_partieEditeur.y = 0;
            }

            Fenetre::~Fenetre()
            {
                SDL_FreeSurface(m_fond);
                SDL_FreeSurface(m_menu);
                SDL_FreeSurface(m_editeur);
            }

            void Fenetre::afficherFond()
            {
                SDL_FillRect(m_ecran, NULL, SDL_MapRGB(m_ecran->format, 0, 0, 0));
                SDL_BlitSurface(m_fond, &m_partieFond, m_ecran, &m_positionFond);
            }

            void Fenetre::miseAJour()
            {
                SDL_Flip(m_ecran);
            }

            SDL_Surface* Fenetre::getEcran()
            {
                return m_ecran;
            }

            void Fenetre::setAfficherVie()
            {
                if(m_afficherVie == false)
                {
                    m_afficherVie = true;
                }
                else
                {
                    m_afficherVie = false;
                }
            }

            bool Fenetre::getAfficherVie()
            {
                return m_afficherVie;
            }

            void Fenetre::setFond(bool avant, long nombre)
            {
                if(avant)
                {
                    m_partieFond.x+=nombre;
                    if(m_partieFond.x > LARGEUR_F)
                    {
                        m_partieFond.x = LARGEUR_F;
                    }
                }
                else
                {
                    m_partieFond.x-=nombre;
                    if(m_partieFond.x < 0)
                    {
                        m_partieFond.x = 0;
                    }
                }
            }

            void Fenetre::afficherMenu()
            {
                SDL_FillRect(m_ecran, NULL, SDL_MapRGB(m_ecran->format, 0, 0, 0));
                SDL_BlitSurface(m_menu, NULL, m_ecran, &m_positionMenu);
            }

            void Fenetre::effacerEcran()
            {
                SDL_FillRect(m_ecran, NULL, SDL_MapRGB(m_ecran->format, 255, 255, 255));
            }

            void Fenetre::coloriage(long x, long y, long taille, long r, long v, long b)
            {
                for(int i = 0 ; i < taille/2 ; i++)
                {
                    for(int j = 0 ; j < taille/2 ; j++)
                    {
                        if(x+taille/2 <= LARGEUR_F && y+taille/2 <= HAUTEUR_F && x-taille/2 >= -1 && y-taille/2 >= -1)
                        {
                            setPixel(m_editeur, x+i, y+j, SDL_MapRGB(m_ecran->format, r, v, b));
                            setPixel(m_editeur, x-i, y-j, SDL_MapRGB(m_ecran->format, r, v, b));
                            setPixel(m_editeur, x-i, y+j, SDL_MapRGB(m_ecran->format, r, v, b));
                            setPixel(m_editeur, x+i, y-j, SDL_MapRGB(m_ecran->format, r, v, b));
                        }
                    }
                }

            }

            void Fenetre::afficherEditeur()
            {
                SDL_BlitSurface(m_editeur, &m_partieEditeur, m_ecran, &m_positionEditeur);
            }

            void Fenetre::afficherOption(long taille, long r, long v, long b)
            {
                SDL_Surface* option = NULL;
                option = SDL_CreateRGBSurface(SDL_HWSURFACE, 100, 100, 32, 0, 0, 0, 0);
                SDL_FillRect(option, NULL, SDL_MapRGB(option->format, 220, 220, 220));
                for(int i = 0 ; i < taille ; i++)
                {
                    for(int j = 0 ; j < taille ; j++)
                    {
                        setPixel(option, i, j, SDL_MapRGB(option->format, r, v, b));
                        setPixel(option, i, j, SDL_MapRGB(option->format, r, v, b));
                        setPixel(option, i, j, SDL_MapRGB(option->format, r, v, b));
                        setPixel(option, i, j, SDL_MapRGB(option->format, r, v, b));
                    }
                }
                SDL_Rect position; position.x = 50; position.y = 50;
                SDL_BlitSurface(option, NULL, m_ecran, &position);
                SDL_FreeSurface(option);
            }





            Donc voilà, la partie la plus interressant est la class Fenetre avec les attributs m_partieFond et m_partieEditeur !

            Ce qui est bizarre c'est que si j'efface ses attributs et que je les réécris aini que les méthodes, une des 2 surfaces fonctionnera correctement et je crois que l'ordre de déclaration (mais ce serait vraiment bizarre) influence qqch ...





            ---------------------------------------------------------------------------------------------------------------------------------------------------------------

            J'ai repéré l'ERREUR !! Ne cherchez plus : Elle est vraiment bizarre et incompréhensible du moins pour un débutant comme moi !
            Voyez par vous-meme dans ce code de Fenetre.hpp:



                    private:

                    bool m_afficherVie;
                    SDL_Surface* m_ecran;
                    SDL_Surface* m_fond;
                    SDL_Surface* m_editeur;
                    SDL_Surface* m_menu;
                    SDL_Rect m_partieEditeur;
                    SDL_Rect m_partieFond;
                    SDL_Rect m_positionFond;
                    SDL_Rect m_positionMenu;
                    SDL_Rect m_positionEditeur;



            Ce code fait fonctionner l'editeur ! Si par contre je déclare m_partieFond avant au lieu de après m_partieEditeur, ce sera le jeu qui marchera !! o_O

            Peut-on m'expliquer parce que là : JE SUIS PERDU ...
            • Partager sur Facebook
            • Partager sur Twitter
              10 juin 2007 à 12:22:27

              Citation : GimralasQS

              Ce code fait fonctionner l'editeur ! Si par contre je déclare m_partieFond avant au lieu de après m_partieEditeur, ce sera le jeu qui marchera !! o_O



              Débordement mémoire probablement (j'ai déjà eu, c'est très rigolo :-° ), mais je ne peux pas t'aider plus désolé, je ne fais pas de C++.
              • Partager sur Facebook
              • Partager sur Twitter
                10 juin 2007 à 14:05:00

                Ca m'étonnerait... vu qu'en plus des variables déclarées après fonctionnent très bien et en plus mon jeu ne représente rien :)

                C'est pas grave je vais passer par une autre solution.
                • Partager sur Facebook
                • Partager sur Twitter

                Besoin d'un (second) petit coup de main

                × 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