Programm schließt sich --> ungültiges Bild?



  • Hi,
    Ich habe dieses http://lazyfoo.net/SDL_tutorials/lesson20/index.php Tutorial gemacht. Nach ein paar Schwierigkeiten mit dem SDL_Image.h(hab das falsch entpackt ins falsche Verzeichnis) kam immerhin keine Fehlermeldung mehr. Das Programm aus dem Tutorial hat sich allerdings sofort geschlossen. Ich hab dann das Strichmännchenbild vom ursprünglichen png-Format ins bmp-Format umgewandelt und es ging. Ich konnte mit dem Strichmännchen rumlaufen. Dann hab ich wieder das png-Format genommen und es ging wieder nicht. Was könnte hierbei falsch sein?

    Und noch ne Frage. Ich habe jemandem die Exe des Programms, die bmp-Datei und die 2 dll´s SDL.dll und SDL_image.dll geschickt. Es ging bei ihm. Als ich es ihm danach ohne die dll´s geschickt hatte gings nicht. Muss man die dll´s für´s Programm also immer mit verpacken oder kann man das irgendwie umgehen?

    Danke schonmal für Antworten:-)





  • Ja ich hab meinen Post nochmal editiert, isses jetzt detailreich genug? Ich weiß einfach nicht warum er das png-Format nicht akzeptiert...Warum läd er das nicht rein sondern beendet sich sofort?:-( Bitte helft mir...

    Hier der Code, ich weiß der ist lang aber ich weiß nicht was jetzt relevant fürs Bild laden ist:

    /*This source code copyrighted by Lazy Foo' Productions (2004-2009) and may not
    be redestributed without written permission.*/
    
    //The headers
    #include "SDL.h"
    #include "SDL_image.h"
    #include <string>
    
    //Screen attributes
    const int SCREEN_WIDTH = 640;
    const int SCREEN_HEIGHT = 480;
    const int SCREEN_BPP = 32;
    
    //The frames per second
    const int FRAMES_PER_SECOND = 10;
    
    //The dimenstions of the stick figure
    const int FOO_WIDTH = 64;
    const int FOO_HEIGHT = 205;
    
    //The direction status of the stick figure
    const int FOO_RIGHT = 0;
    const int FOO_LEFT = 1;
    
    //The surfaces
    SDL_Surface *foo = NULL;
    SDL_Surface *screen = NULL;
    
    //The event structure
    SDL_Event event;
    
    //The areas of the sprite sheet
    SDL_Rect clipsRight[ 4 ];
    SDL_Rect clipsLeft[ 4 ];
    
    //The stick figure
    class Foo
    {
        private:
        //The offset
        int offSet;
    
        //Its rate of movement
        int velocity;
    
        //Its current frame
        int frame;
    
        //Its animation status
        int status;
    
        public:
        //Initializes the variables
        Foo();
    
        //Handles input
        void handle_events();
    
        //Moves the stick figure
        void move();
    
        //Shows the stick figure
        void show();
    };
    
    //The timer
    class Timer
    {
        private:
        //The clock time when the timer started
        int startTicks;
    
        //The ticks stored when the timer was paused
        int pausedTicks;
    
        //The timer status
        bool paused;
        bool started;
    
        public:
        //Initializes variables
        Timer();
    
        //The various clock actions
        void start();
        void stop();
        void pause();
        void unpause();
    
        //Gets the timer's time
        int get_ticks();
    
        //Checks the status of the timer
        bool is_started();
        bool is_paused();
    };
    
    SDL_Surface *load_image( std::string filename )
    {
        //The image that's loaded
        SDL_Surface* loadedImage = NULL;
    
        //The optimized surface that will be used
        SDL_Surface* optimizedImage = NULL;
    
        //Load the image
        loadedImage = IMG_Load( filename.c_str() );
    
        //If the image loaded
        if( loadedImage != NULL )
        {
            //Create an optimized surface
            optimizedImage = SDL_DisplayFormat( loadedImage );
    
            //Free the old surface
            SDL_FreeSurface( loadedImage );
    
            //If the surface was optimized
            if( optimizedImage != NULL )
            {
                //Color key surface
                SDL_SetColorKey( optimizedImage, SDL_SRCCOLORKEY, SDL_MapRGB( optimizedImage->format, 0, 0xFF, 0xFF ) );
            }
        }
    
        //Return the optimized surface
        return optimizedImage;
    }
    
    void apply_surface( int x, int y, SDL_Surface* source, SDL_Surface* destination, SDL_Rect* clip = NULL )
    {
        //Holds offsets
        SDL_Rect offset;
    
        //Get offsets
        offset.x = x;
        offset.y = y;
    
        //Blit
        SDL_BlitSurface( source, clip, destination, &offset );
    }
    
    void set_clips()
    {
        //Clip the sprites
        clipsRight[ 0 ].x = 0;
        clipsRight[ 0 ].y = 0;
        clipsRight[ 0 ].w = FOO_WIDTH;
        clipsRight[ 0 ].h = FOO_HEIGHT;
    
        clipsRight[ 1 ].x = FOO_WIDTH;
        clipsRight[ 1 ].y = 0;
        clipsRight[ 1 ].w = FOO_WIDTH;
        clipsRight[ 1 ].h = FOO_HEIGHT;
    
        clipsRight[ 2 ].x = FOO_WIDTH * 2;
        clipsRight[ 2 ].y = 0;
        clipsRight[ 2 ].w = FOO_WIDTH;
        clipsRight[ 2 ].h = FOO_HEIGHT;
    
        clipsRight[ 3 ].x = FOO_WIDTH * 3;
        clipsRight[ 3 ].y = 0;
        clipsRight[ 3 ].w = FOO_WIDTH;
        clipsRight[ 3 ].h = FOO_HEIGHT;
    
        clipsLeft[ 0 ].x = 0;
        clipsLeft[ 0 ].y = FOO_HEIGHT;
        clipsLeft[ 0 ].w = FOO_WIDTH;
        clipsLeft[ 0 ].h = FOO_HEIGHT;
    
        clipsLeft[ 1 ].x = FOO_WIDTH;
        clipsLeft[ 1 ].y = FOO_HEIGHT;
        clipsLeft[ 1 ].w = FOO_WIDTH;
        clipsLeft[ 1 ].h = FOO_HEIGHT;
    
        clipsLeft[ 2 ].x = FOO_WIDTH * 2;
        clipsLeft[ 2 ].y = FOO_HEIGHT;
        clipsLeft[ 2 ].w = FOO_WIDTH;
        clipsLeft[ 2 ].h = FOO_HEIGHT;
    
        clipsLeft[ 3 ].x = FOO_WIDTH * 3;
        clipsLeft[ 3 ].y = FOO_HEIGHT;
        clipsLeft[ 3 ].w = FOO_WIDTH;
        clipsLeft[ 3 ].h = FOO_HEIGHT;
    }
    
    bool init()
    {
        //Initialize all SDL subsystems
        if( SDL_Init( SDL_INIT_EVERYTHING ) == -1 )
        {
            return false;
        }
    
        //Set up the screen
        screen = SDL_SetVideoMode( SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_BPP, SDL_SWSURFACE );
    
        //If there was an error in setting up the screen
        if( screen == NULL )
        {
            return false;
        }
    
        //Set the window caption
        SDL_WM_SetCaption( "Animation Test", NULL );
    
        //If everything initialized fine
        return true;
    }
    
    bool load_files()
    {
        //Load the sprite sheet
        foo = load_image( "foo.bmp" );
    
        //If there was a problem in loading the sprite
        if( foo == NULL )
        {
            return false;
        }
    
        //If everything loaded fine
        return true;
    }
    
    void clean_up()
    {
        //Free the surface
        SDL_FreeSurface( foo );
    
        //Quit SDL
        SDL_Quit();
    }
    
    Foo::Foo()
    {
        //Initialize movement variables
        offSet = 0;
        velocity = 0;
    
        //Initialize animation variables
        frame = 0;
        status = FOO_RIGHT;
    }
    
    void Foo::handle_events()
    {
        //If a key was pressed
        if( event.type == SDL_KEYDOWN )
        {
            //Set the velocity
            switch( event.key.keysym.sym )
            {
                case SDLK_RIGHT: velocity += FOO_WIDTH / 5; break;
                case SDLK_LEFT: velocity -= FOO_WIDTH / 5; break;
            }
        }
        //If a key was released
        else if( event.type == SDL_KEYUP )
        {
            //Set the velocity
            switch( event.key.keysym.sym )
            {
                case SDLK_RIGHT: velocity -= FOO_WIDTH / 5; break;
                case SDLK_LEFT: velocity += FOO_WIDTH / 5; break;
            }
        }
    }
    
    void Foo::move()
    {
        //Move
        offSet += velocity;
    
        //Keep the stick figure in bounds
        if( ( offSet < 0 ) || ( offSet + FOO_WIDTH > SCREEN_WIDTH ) )
        {
            offSet -= velocity;
        }
    }
    
    void Foo::show()
    {
        //If Foo is moving left
        if( velocity < 0 )
        {
            //Set the animation to left
            status = FOO_LEFT;
    
            //Move to the next frame in the animation
            frame++;
        }
        //If Foo is moving right
        else if( velocity > 0 )
        {
            //Set the animation to right
            status = FOO_RIGHT;
    
            //Move to the next frame in the animation
            frame++;
        }
        //If Foo standing
        else
        {
            //Restart the animation
            frame = 0;
        }
    
        //Loop the animation
        if( frame >= 4 )
        {
            frame = 0;
        }
    
        //Show the stick figure
        if( status == FOO_RIGHT )
        {
            apply_surface( offSet, SCREEN_HEIGHT - FOO_HEIGHT, foo, screen, &clipsRight[ frame ] );
        }
        else if( status == FOO_LEFT )
        {
            apply_surface( offSet, SCREEN_HEIGHT - FOO_HEIGHT, foo, screen, &clipsLeft[ frame ] );
        }
    }
    
    Timer::Timer()
    {
        //Initialize the variables
        startTicks = 0;
        pausedTicks = 0;
        paused = false;
        started = false;
    }
    
    void Timer::start()
    {
        //Start the timer
        started = true;
    
        //Unpause the timer
        paused = false;
    
        //Get the current clock time
        startTicks = SDL_GetTicks();
    }
    
    void Timer::stop()
    {
        //Stop the timer
        started = false;
    
        //Unpause the timer
        paused = false;
    }
    
    void Timer::pause()
    {
        //If the timer is running and isn't already paused
        if( ( started == true ) && ( paused == false ) )
        {
            //Pause the timer
            paused = true;
    
            //Calculate the paused ticks
            pausedTicks = SDL_GetTicks() - startTicks;
        }
    }
    
    void Timer::unpause()
    {
        //If the timer is paused
        if( paused == true )
        {
            //Unpause the timer
            paused = false;
    
            //Reset the starting ticks
            startTicks = SDL_GetTicks() - pausedTicks;
    
            //Reset the paused ticks
            pausedTicks = 0;
        }
    }
    
    int Timer::get_ticks()
    {
        //If the timer is running
        if( started == true )
        {
            //If the timer is paused
            if( paused == true )
            {
                //Return the number of ticks when the timer was paused
                return pausedTicks;
            }
            else
            {
                //Return the current time minus the start time
                return SDL_GetTicks() - startTicks;
            }
        }
    
        //If the timer isn't running
        return 0;
    }
    
    bool Timer::is_started()
    {
        return started;
    }
    
    bool Timer::is_paused()
    {
        return paused;
    }
    
    int main( int argc, char* args[] )
    {
        //Quit flag
        bool quit = false;
    
        //Initialize
        if( init() == false )
        {
            return 1;
        }
    
        //Load the files
        if( load_files() == false )
        {
            return 1;
        }
    
        //Clip the sprite sheet
        set_clips();
    
        //The frame rate regulator
        Timer fps;
    
        //The stick figure
        Foo walk;
    
        //While the user hasn't quit
        while( quit == false )
        {
            //Start the frame timer
            fps.start();
    
            //While there's events to handle
            while( SDL_PollEvent( &event ) )
            {
                //Handle events for the stick figure
                walk.handle_events();
    
                //If the user has Xed out the window
                if( event.type == SDL_QUIT )
                {
                    //Quit the program
                    quit = true;
                }
            }
    
            //Move the stick figure
            walk.move();
    
            //Fill the screen white
            SDL_FillRect( screen, &screen->clip_rect, SDL_MapRGB( screen->format, 0xff, 0xff, 0xff ) );
    
            //Show the stick figure on the screen
            walk.show();
    
            //Update the screen
            if( SDL_Flip( screen ) == -1 )
            {
                return 1;
            }
    
            //Cap the frame rate
            if( fps.get_ticks() < 1000 / FRAMES_PER_SECOND )
            {
                SDL_Delay( ( 1000 / FRAMES_PER_SECOND ) - fps.get_ticks() );
            }
        }
    
        //Clean up
        clean_up();
    
        return 0;
    }
    


  • Du lädst im Programm die Datei foo.bmp wie verwunderlich ist es da, dass er die Datei foo.png nicht beachtet?

    Noch was allgemeines:
    Wenn Du nicht weißt, welcher Teil des Codes relevant für die Bilder bist, dann solltest Du besser nochmal nen Schritt zurück tun. Entweder nochmal ein paar C++-Grundlagen aufarbeiten (wenn Du passende Bücher oder Tutorials brauchst, dann frag hier nach), oder doch zumindest nochmal zum Anfang des von Dir verlinkten Tutorials zurück. Du hast einfach ein paar Grundlagen verpasst, ohne die Dir der weitere Fortschritt schwer fallen wird.



  • Nene der Fehler lag wo anders. Dass in dem Code noch foo.bmp stand liegt daran dass es damit ging und ich beim posten nicht nochmal geschaut hatte was ich geschrieben hatte. Ich weiß schon in welchem Bereich mit welchen Befehlen das Bild und die Grafikoberfläche initialisiert wird, aber es hätte ja sein können ich hab irgendwas übersehen oder es gibt was wichtiges was ich noch nicht verstanden habe was für den Fehler verantwortlich ist.

    Aber das Problem ist jetzt geklärt^^ Ich hatte ne bestimmte *.dll-Datei zum einbinden von png noch nicht in system32-Ordner. So was simples:p


Anmelden zum Antworten