Fehler beim Laden des Bildes nach 1 Minute und 22 Sekunden

Question

Ich mache ein einfaches Space-Invaders-ähnliches Spiel in C++ mit sdl2. Die Dinge liefen super. Das Spiel hat gut funktioniert, bis ich bemerkt habe, dass SDL nach etwa 1 Minute und 22 Sekunden keine meiner PNGs lädt. Es hört einfach auf, aus welchem ​​Grund auch immer zu arbeiten. Ich habe stundenlang versucht, ähnliche Probleme zu finden, aber ohne Glück. (Ich bin ziemlich neu in der Spieleentwicklung und der grafischen Programmierung im Allgemeinen).

main.cpp:

#include "SpaceInv.h" 


int main(int argc, char* args[]) { 
    SpaceInv si; 
    si.StartGame(); 
    return 0; 
} 

SpaceInv.h:

#pragma once 
#ifndef SPACEINV 
#define SPACEINV 
#include <SDL_mixer.h> 
#include "Ship.h" 
#include "SpaceContainer.h" 
#include "ScoreBoard.h" 

class SpaceInv { 
public: 
    SpaceInv(); 
    ~SpaceInv(); 
    void StartGame(); 
    void Close(); 
    bool Initialize(); 
    SDL_Texture* LoadTexture(std::string file); 
    void generateEnemy(); 
    void generateAsteroid(); 
    bool checkCollitions(SDL_Rect& a, SDL_Rect& b); 
    int randNum(int min, int max); 
private: 
    const int SCREEN_WIDTH = 720; 
    const int SCREEN_HEIGHT = 480; 
    SDL_Window* window = NULL; 
    SDL_Surface* screen = NULL; 
    SDL_Renderer* renderer = NULL; 
    SDL_Texture* background = NULL; 
    Ship ship; 
    ScoreBoard score; 
    int frameWidth, frameHeight; 
    int textureWidth, textureHeight; 
    SpaceContainer lazers; 
    SpaceContainer explosions; 
    SpaceContainer enemyLazers; 
    SpaceContainer asteroids; 
    SpaceContainer enemyShips; 

}; 

#endif 

SpaceInv.cpp:

#include "SpaceInv.h" 
#include "Asteroid.h" 
#include <SDL_ttf.h> 
#include <random> 


SpaceInv::SpaceInv(){ 
} 
SpaceInv::~SpaceInv(){} 

void SpaceInv::StartGame() { 
    if (!Initialize()) { 
     printf("Could not initialize!\n"); 
     return; 
    } 

    //load background music 
    Mix_Chunk *bgm = Mix_LoadWAV("bgm.wav"); 
    Mix_Chunk *lazerBeam = Mix_LoadWAV("Lazerbeam.wav"); 

    if (!bgm) { 
     std::cout << "no music found..." << std::endl; 
    } 
    Mix_PlayChannel(0, bgm, 0); 

    if (bgm==NULL) { 
     std::cout << "no music found..." << std::endl; 
    } 

    background = LoadTexture("img.png"); 
    ship.setSpriteName("ship.png"); 
    ship.setTexture(renderer); 

    score.setTexture(renderer, "Score: 0"); 


    int points = 0; 
    const int FPS = 60; 
    int frameTime = 0; 

    bool exit = false; 


    while (!exit) { 

     SDL_Event e; 
     while (SDL_PollEvent(&e) != 0) { 

      if (e.type == SDL_QUIT || e.key.keysym.sym == SDLK_ESCAPE) { 
       exit = true; 
      } 

      if (e.type == SDL_KEYDOWN) { 


       if (e.key.keysym.sym==SDLK_LEFT){ 
        ship.moveX(-1); //std::cout << "left"; 
       } 
       if (e.key.keysym.sym == SDLK_RIGHT){ 
        ship.moveX(1); //std::cout << "Right"; 

       } 
       if (e.key.keysym.sym == SDLK_UP){ 
        ship.moveY(-1); //std::cout << "UP"; 
       } 
       if (e.key.keysym.sym == SDLK_DOWN){ 
        ship.moveY(1); //std::cout << "DOWN"; 
       } 
       if (e.key.keysym.sym == SDLK_SPACE && e.key.repeat==0) { 
        //skapa laser om input = SPACE 
        SpaceObject lazer("lazer.png", ship.getPos(), 5, 10); 
        lazer.setSpriteName("lazer.png"); 

        int x = ship.getPos().x; 
        int y = ship.getPos().y - 20; 

        lazer.setPos(x , y); 
        lazer.setTexture(renderer); 
        lazers.pushBack(lazer); 
        Mix_PlayChannel(1, lazerBeam, 0); 
        //std::cout << "SPACE"; 
       } 
      } 

     } 

     frameTime++; 
     if (FPS/frameTime == 4) { 
      frameTime = 0; 

      //animate ship 
      ship.animate(); 

      //animate lazers 
      for (size_t i = 0; i < lazers.size(); i++) { 
       lazers.getObject(i).animate(); 
      } 

      //animate asteroids 
      for (size_t i = 0; i < asteroids.size(); i++) { 
       asteroids.getObject(i).animate(); 
      } 

      //animate enemy lazers 
      for (size_t i = 0; i < enemyLazers.size(); i++) { 
       enemyLazers.getObject(i).animate(); 
      } 

      //animate enemy ships 
      for (size_t i = 0; i < enemyShips.size(); i++) { 
       enemyShips.getObject(i).animate(); 
      } 

      //animate explosions 
      for (size_t i = 0; i < explosions.size(); i++){ 
       explosions.getObject(i).animate(); 
      } 

     } 

     //random generate asteroids 
     if (randNum(1, 100) >= 99) { 
      generateAsteroid(); 
     } 
     //random generate enemy ships 
     if (randNum(-200, 200) >= 199) { 
      generateEnemy(); 
     } 

     //make enemy ships fire at random 
     for (size_t i = 0; i < enemyShips.size(); i++){ 
      if (randNum(0, 200) >= 199) { 
       SpaceObject enemyLazer("lazer.png", enemyShips.getObject(i).getPos(), 5, -10); 
       enemyLazer.setSpriteName("lazer.png"); 
       enemyLazer.setTexture(renderer); 
       enemyLazers.pushBack(enemyLazer); 
       Mix_PlayChannel(i+2, lazerBeam, 0); 
      } 
     } 
     //clear the renderer 
     SDL_RenderClear(renderer); 

     //render ship and background image 
     SDL_RenderCopy(renderer, background, NULL, NULL); 
     SDL_RenderCopy(renderer, ship.getTexture(), &ship.getRect(), &ship.getPos()); 

     //rendrer scoreboard 
     SDL_RenderCopy(renderer, score.getTexture(), NULL, &score.getPos()); 

     //uppdate and render lazers 
     for (size_t i = 0; i < lazers.size(); i++) { 

      lazers.getObject(i).moveY(); 
      SDL_RenderCopy(renderer, lazers.getObject(i).getTexture(), &lazers.getObject(i).getRect(), 
       &lazers.getObject(i).getPos()); 
     } 

     //uppdate and render asteroids 
     for (size_t i = 0; i < asteroids.size(); i++) { 
      asteroids.getObject(i).moveY(); 
      SDL_RenderCopy(renderer, asteroids.getObject(i).getTexture(), &asteroids.getObject(i).getRect(), 
       &asteroids.getObject(i).getPos()); 
     } 

     //uppdate and render enemy lazers 
     for (size_t i = 0; i < enemyLazers.size(); i++) { 
      enemyLazers.getObject(i).moveY(); 
      SDL_RenderCopy(renderer, enemyLazers.getObject(i).getTexture(), &enemyLazers.getObject(i).getRect(), 
       &enemyLazers.getObject(i).getPos()); 
     } 

     //uppdate and render enemy ships 
     for (size_t i = 0; i < enemyShips.size(); i++) { 
      enemyShips.getObject(i).moveY(); 
      SDL_RenderCopy(renderer, enemyShips.getObject(i).getTexture(), &enemyShips.getObject(i).getRect(), 
       &enemyShips.getObject(i).getPos()); 
     } 

     //render explosions 
     for (size_t i = 0; i < explosions.size(); i++) { 

      SDL_RenderCopy(renderer, explosions.getObject(i).getTexture(), &explosions.getObject(i).getRect(), 
       &explosions.getObject(i).getPos()); 
     } 

     //look for collisions between lazers and enemy ships 
     for (size_t i = 0; i < lazers.size(); i++) { 

      for (size_t j = 0; j < enemyShips.size(); j++) { 
       if (checkCollitions(lazers.getObject(i).getPos(), enemyShips.getObject(j).getPos())) { 

        //std::cout << "collision!!" << std::endl; 
        lazers.getObject(i).setTimeToLive(0); 
        enemyShips.getObject(j).setTimeToLive(0); 

        SpaceObject explosion("explosion.png", enemyShips.getObject(j).getPos(), 1, 0); 
        explosion.setSpriteName("explosion.png"); 
        //lazer.setPos(ship.getPos()); 
        explosion.setTexture(renderer); 
        explosions.pushBack(explosion); 

        points += 10; 
       } 
      } 
     } 

     ////look for collisions between lazers and asteroids 
     for (size_t i = 0; i < lazers.size(); i++) { 

      for (size_t j = 0; j < asteroids.size(); j++) { 
       if (checkCollitions(lazers.getObject(i).getPos(), asteroids.getObject(j).getPos())) { 

        //std::cout << "collision!!" << std::endl; 
        lazers.getObject(i).setTimeToLive(0); 
        asteroids.getObject(j).setTimeToLive(0); 

        SpaceObject explosion("explosion.png", asteroids.getObject(j).getPos(), 1, 0); 
        explosion.setSpriteName("explosion.png"); 
        //lazer.setPos(ship.getPos()); 
        explosion.setTexture(renderer); 
        explosions.pushBack(explosion); 

        points += 2; 
       } 
      } 
     } 
     ////look for collisions between ship and asteroids 
     for (size_t i = 0; i < asteroids.size(); i++) { 

      if (checkCollitions(ship.getPos(), asteroids.getObject(i).getPos())) { 

       //exit = true; 

      } 
     } 

     ////look for collisions between ship and enemy lazers 
     for (size_t i = 0; i < enemyLazers.size(); i++) { 

      if (checkCollitions(ship.getPos(), enemyLazers.getObject(i).getPos())) { 

       //exit = true; 

      } 
     } 

     //check the lifetime of every object on the screen. 
     enemyShips.checkLifetime(); 
     enemyLazers.checkLifetime(); 
     asteroids.checkLifetime(); 
     lazers.checkLifetime(); 
     explosions.checkLifetime(); 

     //update score 
     score.setTexture(renderer, "Score: " + std::to_string(points)); 

     SDL_RenderPresent(renderer); 

    } 
    Close(); 

    return; 
} 

bool SpaceInv::Initialize() { 
    if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO)) { 
     printf("SDL could not be initialized! SDL Error %s\n", SDL_GetError); 
     return false; 
    } 
    window = SDL_CreateWindow("Super Space Wars Extreme", 
     SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, 
     SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN); 

    if (window == NULL) { 
     printf("Window could not be created! SDL Error %s\n", SDL_GetError); 
     return false; 
    } 
    //screen = SDL_GetWindowSurface(window); 
    renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC); 
    if (renderer == NULL) { 
     printf("Not able to create renderer! SDL Error %s\n", SDL_GetError); 
     return false; 
    } 

    SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255); 

    int imgFlags = IMG_INIT_PNG; 
    if (!IMG_Init(imgFlags & imgFlags)) { 

     printf("SDL_image could not be initialized! SDL_image Error %s\n", IMG_GetError); 
     return false; 
    } 

    if (TTF_Init() == -1) 
    { 
     std::cout << "Init TTF failt : " << SDL_GetError() << std::endl; 
     return false; 
    } 

    /*if (Mix_Init() == -1) { 
     std::cout << "Audio Error : " << Mix_GetError() << std::endl; 
    }*/ 

    if(Mix_OpenAudio(44100, MIX_DEFAULT_FORMAT, 2, 2048) < 0){ 
     std::cout << "Audio Error : " << Mix_GetError() << std::endl; 
    } 

    return true; 

} 
SDL_Texture* SpaceInv::LoadTexture(std::string file) { 

    SDL_Texture* newTexture = NULL; 
    SDL_Surface* loadedSurface = IMG_Load(file.c_str()); 
    if (loadedSurface == NULL) { 
     printf("Unable to load image! SDL_image Error %s\n", file.c_str(), IMG_GetError); 
    } 
    else { 
     newTexture = SDL_CreateTextureFromSurface(renderer, loadedSurface); 
     if (newTexture == NULL) { 
      printf("Unable to create the texture from %s! SDL_image Error %s\n", SDL_GetError); 

      SDL_FreeSurface(loadedSurface); 
     } 
    } 
    return newTexture; 

} 

void SpaceInv::generateAsteroid() { 
    SpaceObject asteroid(20, -randNum(1,5)); //TODO kolla livslängd 
    asteroid.setSpriteName("asteroid.png"); 

    asteroid.setTexture(renderer); 

    asteroid.setPos(randNum(0, SCREEN_WIDTH) , -200); 
    asteroid.makeEnemy(); 
    asteroid.changeSpriteSize(8, 8, 128); 

    asteroids.pushBack(asteroid); 
} 

void SpaceInv::generateEnemy() { 
    SpaceObject enemy(20, -2); //TODO kolla livslängd 
    enemy.setSpriteName("enemyship.png"); 

    enemy.setTexture(renderer); 

    enemy.setPos(randNum(0, SCREEN_WIDTH), -200); 
    enemy.makeEnemy(); 


    enemyShips.pushBack(enemy); 
} 

int SpaceInv::randNum(int min, int max) { 
    int output = min + (rand() % static_cast<int>(max - min + 1)); 

    return output; 
} 


bool SpaceInv::checkCollitions(SDL_Rect& a, SDL_Rect& b) { 
    //The sides of the rectangles 
    int leftA, leftB; 
    int rightA, rightB; 
    int topA, topB; 
    int bottomA, bottomB; 

    leftA = a.x; 
    rightA = a.x + a.w; 
    topA = a.y; 
    bottomA = a.y + a.h; 

    leftB = b.x; 
    rightB = b.x + b.w; 
    topB = b.y; 
    bottomB = b.y + b.h; 
    if (bottomA <= topB) { 
     return false; 
    } 

    if (topA >= bottomB) { 
     return false; 
    } 

    if (rightA <= leftB) { 
     return false; 
    } 

    if (leftA >= rightB) { 
     return false; 
    } 

    //If none of the sides from A are outside B 
    return true; 
} 

void SpaceInv::Close() { 
    SDL_DestroyWindow(window); 
    window = NULL; 

    Mix_Quit(); 
    SDL_Quit(); 
} 

SpaceObject.h

#pragma once 
#ifndef SPACEOBJECT 
#define SPACEOBJECT 

#include <SDL.h> 
#include <stdio.h> 
#include <SDL_image.h> 
#include <string> 
#include <ctime> 

class SpaceObject { 
public: 
    SpaceObject(); 
    SpaceObject(double t, int sp); 
    SpaceObject(std::string s, SDL_Rect startPos, double t, int sp); 
    ~SpaceObject(); 
    double getDuration(); 
    double getTimeToLive(); 
    void setSpriteName(std::string s); 
    void setTimeToLive(int i); 
    std::string getSpriteName(); 
    void setTexture(SDL_Renderer* &renderer); 
    SDL_Texture*& getTexture(); 
    SDL_Rect getRect(); 
    SDL_Rect* getRectP(); 
    SDL_Rect getPos(); 
    void setPos(int x, int y); 
    void moveY(); 
    void animate(); 
    void makeEnemy(); 
    void changeSpriteSize(int a, int b, int c); 
    bool isEnemy(); 
protected: 
    //int test; 
    std::string spriteName; 
    SDL_Texture* texture; 
    SDL_Rect sprite; 
    SDL_Rect pos; 
    int speed; 
    int frameWidth, frameHeight; 
    int textureWidth, textureHeight; 
    bool enemy = false; 
    bool asteroid = false; 
    bool lazer = false; 
    double timeToLive; 
    double duration; 
    std::clock_t start; 
}; 

#endif 

SpaceObject.cpp

#include "SpaceObject.h" 
    #include <iostream> 

SpaceObject::SpaceObject(){} 

SpaceObject::SpaceObject(double t, int sp):timeToLive(t), speed(sp) { 
    start = std::clock(); 
    enemy = false; 
} 

SpaceObject::SpaceObject(std::string s, SDL_Rect startPos, double t, int sp) : spriteName(s), timeToLive(t), pos(startPos), speed(sp) { 
    //pos.y = pos.y - 27; 
    start = std::clock(); 
    enemy = false; 
} 
SDL_Rect* SpaceObject::getRectP() { 
    return &sprite; 
} 
void SpaceObject::makeEnemy() { 

    enemy = true; 
} 
void SpaceObject::changeSpriteSize(int a, int b, int c){ 
    frameWidth = textureWidth/a; 
    frameHeight = textureHeight/b; 
    sprite.w = frameWidth; 
    sprite.h = frameHeight; 

    sprite.h = sprite.w = c; 
} 
bool SpaceObject::isEnemy() { 
    //enemy = false; 
    ////std::cout.setf(std::ios::boolalpha); 
    ////std::cout << enemy << std::endl; 
    return enemy; 
} 
void SpaceObject::setTimeToLive(int i) { 
    timeToLive = i; 
} 
void SpaceObject::setPos(int x, int y) { 
    pos.x = x; 
    pos.y = y; 
} 

SDL_Rect SpaceObject::getPos() { 
    //pos.y = pos.y - 5; 
    return pos; 
} 

double SpaceObject::getTimeToLive() { return timeToLive; } 
std::string SpaceObject::getSpriteName() { return spriteName; } 

void SpaceObject::setSpriteName(std::string s) { 
    spriteName = s; 
} 



void SpaceObject::setTexture(SDL_Renderer* &renderer) { 
    ////std::cout << spriteName << std::endl; 
    SDL_Texture* newTexture = NULL; 
    SDL_Surface* loadedSurface = IMG_Load(spriteName.c_str()); 
    if (loadedSurface == NULL) { 
     printf("Unable to load image! SDL_image Error %s\n", spriteName.c_str(), IMG_GetError); 
    } 
    else { 
     newTexture = SDL_CreateTextureFromSurface(renderer, loadedSurface); 
     if (newTexture == NULL) { 
      printf("Unable to create the texture from %s! SDL_image Error %s\n", SDL_GetError); 

      SDL_FreeSurface(loadedSurface); 
     } 
    } 
    texture = newTexture; 
    SDL_QueryTexture(texture, NULL, NULL, &textureWidth, &textureHeight); 

    frameWidth = textureWidth /2; 
    frameHeight = textureHeight /2; 
    //sprite.x = 0; 
    //sprite.y = 0; 
    sprite.w = frameWidth; 
    sprite.h = frameHeight; 

    pos.w = pos.h = 64; 



} 

SDL_Rect SpaceObject::getRect() { 
    return sprite; 
} 

void SpaceObject::animate() { 
    sprite.x += frameWidth; 

    if (sprite.x >= textureWidth) { 

     sprite.x = 0; 
     sprite.y += frameHeight; 

     if (sprite.y >= textureWidth) { 
      sprite.y = 0; 
     } 
    } 
} 



void SpaceObject::moveY() { 
    pos.y = pos.y - speed; 
} 


double SpaceObject::getDuration() { 
    duration = (std::clock() - start)/(double)CLOCKS_PER_SEC; 
    return duration; 
} 
SDL_Texture*& SpaceObject::getTexture() { return texture; } 
SpaceObject::~SpaceObject() { ////std::cout << "Rymdobjekt borttaget" << std::endl; 
} 

Ship.h

#pragma once 
#ifndef SHIP 
#define SHIP 
// "Lazer.h" 
#include <SDL.h> 
#include <stdio.h> 
#include <SDL_image.h> 
#include <string> 
#include <iostream> 
#include <string> 
#include <thread> 
//#include "SpaceInv.h" 

class Ship { 
public: 
    Ship(); 
    Ship(std::string s); 
    ~Ship(); 
    void setSpriteName(std::string s); 
    std::string getSpriteName(); 
    void setTexture(SDL_Renderer* &renderer); 
    SDL_Texture*& getTexture(); 
    void animate(); 
    SDL_Rect getRect(); 
    SDL_Rect getPos(); 
    //SDL_Texture*& Ship::fire(int speed, SDL_Rect start, SDL_Renderer* &renderer); 
    //void fire(int speed, SDL_Rect start); 
    void moveX(int speed); 
    void moveY(int speed); 



private: 
    std::string spriteName; 
    SDL_Texture* texture; 
    SDL_Rect sprite; 
    SDL_Rect pos; 
    int frameWidth, frameHeight; 
    int textureWidth, textureHeight; 
    const int SCREEN_WIDTH = 720; 
    const int SCREEN_HEIGHT = 480; 


}; 

#endif 

Ship.cpp

#include "Ship.h" 
//#include "Lazer.h" 
Ship::Ship(){} 

Ship::Ship(std::string s):spriteName(s){} 


std::string Ship::getSpriteName() { return spriteName; } 

void Ship::setSpriteName(std::string s) { 
    spriteName = s; 
} 

SDL_Texture*& Ship::getTexture(){ return texture; } 

void Ship::setTexture(SDL_Renderer* &renderer) { 

    SDL_Texture* newTexture = NULL; 
    SDL_Surface* loadedSurface = IMG_Load(spriteName.c_str()); 
    if (loadedSurface == NULL) { 
     printf("Unable to load image! SDL_image Error %s\n", spriteName.c_str(), IMG_GetError); 
    } 
    else { 
     newTexture = SDL_CreateTextureFromSurface(renderer, loadedSurface); 
     if (newTexture == NULL) { 
      printf("Unable to create the texture from %s! SDL_image Error %s\n", SDL_GetError); 

      SDL_FreeSurface(loadedSurface); 
     } 
    } 
    texture = newTexture; 

    SDL_QueryTexture(texture, NULL, NULL, &textureWidth, &textureHeight); 


    pos.w = pos.h = 64; 
    pos.x = 340; 
    pos.y = 255; 

    frameWidth = 192/2; 
    frameHeight = 192/2; 
    sprite.x = 0; 
    sprite.y = 0; 
    sprite.w = frameWidth; 
    sprite.h = frameHeight; 
} 

SDL_Rect Ship::getRect() { 
    return sprite; 
} 

SDL_Rect Ship::getPos() { 
    return pos; 
} 

void Ship::moveX(int speed){ 
    if ((pos.x <= 0 && speed<0) || (pos.x >= SCREEN_WIDTH && speed>0)) { 
     //std:://std:://std::cout << "/n"; 
     return; 
    } 
    pos.x = pos.x +speed*(SCREEN_WIDTH/20); 
} 

void Ship::moveY(int speed) { 
    if ((pos.y <= 0 && speed<0) || (pos.y >= SCREEN_HEIGHT && speed>0)) { 
     return; 
    } 
    pos.y = pos.y + speed*(SCREEN_WIDTH/20); 
} 

void Ship::animate() { 
    sprite.x += frameWidth; 

    if (sprite.x >= textureWidth) { 

     sprite.x = 0; 
     sprite.y += frameHeight; 

     if (sprite.y >= textureWidth) { 
      sprite.y = 0; 
     } 
    } 
} 
/* 
SDL_Texture*& Ship::fire(int speed, SDL_Rect start, SDL_Renderer* &renderer) { 
    Lazer lazer("lazer.png", start); 
    lazer.setTexture(renderer); 
    return lazer.getTexture(); 

}*/ 

Ship::~Ship() {} 

SpaceContainer.h

#pragma once 
#ifndef SPACECONTAINER 
#define SPACECONTAINER 
#include <SDL.h> 
#include <stdio.h> 
#include <SDL_image.h> 
#include <string> 
#include <iostream> 
#include <string> 
#include <vector> 
#include "SpaceObject.h" 
//#include "SpaceInv.h" 

class SpaceContainer { 
public: 
    SpaceContainer(); 
    ~SpaceContainer(); 
    SpaceObject& getObject(int i); 
    std::vector<SpaceObject>& getVec(); 
    void checkLifetime(); 
    void pushBack(SpaceObject o); 
    void popAt(int i); 
    bool checkCollitions(SDL_Rect& a, SDL_Rect& b); 

    size_t size(); 



private: 
    std::vector<SpaceObject> vec; 
}; 

#endif 

SpaceContainer.cpp

#include "SpaceContainer.h" 

SpaceContainer::SpaceContainer(){} 

void SpaceContainer::checkLifetime(){ 
    if (vec.empty()) { 
     return; 
    } 
    for (size_t i = 0; i < vec.size(); i++) 
     { 
      ////std::cout << vec[i].getDuration() << std::endl; 
      if (vec[i].getDuration() >= vec[i].getTimeToLive()) { 
       vec.erase(vec.begin() + i); 
      // delete &vec[i]; 
       ////std::cout << "Object destroyed " << std::endl; 
      } 
     } 
} 

void SpaceContainer::popAt(int i) { 
    vec.erase(vec.begin() + i); 
} 

void SpaceContainer::pushBack(SpaceObject o) { 
    vec.push_back(o); 
} 

SpaceObject& SpaceContainer::getObject(int i) { 
    return vec.at(i); 
} 
std::vector<SpaceObject>& SpaceContainer::getVec() { 
    return vec; 
} 


size_t SpaceContainer::size(){ 
    return vec.size(); 
} 

SpaceContainer::~SpaceContainer(){} 

ScoreBoard.h

#pragma once 
#ifndef SCOREBOARD 
#define SCOREBOARD 
#include <SDL.h> 
#include <stdio.h> 
#include <SDL_image.h> 
#include <string> 
#include <iostream> 
#include <string> 
#include <thread> 
#include <SDL_ttf.h> 


class ScoreBoard { 
public: 
    ScoreBoard(); 
    void setTexture(SDL_Renderer* &renderer, std::string mes); 
    SDL_Texture*& getTexture(); 
    SDL_Rect getRect(); 
    SDL_Rect getPos(); 
    ~ScoreBoard(); 

private: 
    SDL_Rect sprite; 
    SDL_Rect pos; 
    SDL_Texture* texture; 
}; 

#endif 

ScoreBoard.cpp

#include "ScoreBoard.h" 
#include <SDL_ttf.h> 
#include <SDL_mixer.h> 
ScoreBoard::ScoreBoard(){} 

SDL_Texture*& ScoreBoard::getTexture() { return texture; } 

SDL_Rect ScoreBoard::getRect() { 
    return sprite; 
} 

SDL_Rect ScoreBoard::getPos() { 
    return pos; 
} 

void ScoreBoard::setTexture(SDL_Renderer* &renderer, std::string mes) { 
    TTF_Font* Sans = TTF_OpenFont("FreeSansBold.ttf", 24); 
    SDL_Color White = { 255, 255, 255 }; 

    if (!Sans) { 
     std::cout << "font not found..." << std::endl; 
     return; 
    } 


    const char * c = mes.c_str(); 
    SDL_Surface* surfaceMessage = TTF_RenderText_Solid(Sans, c, White); 

    texture = SDL_CreateTextureFromSurface(renderer, surfaceMessage); 

    pos.w = 128; 
    pos.h = 64; 
    pos.x = 15; 
    pos.y = 5; 

} 

ScoreBoard::~ScoreBoard(){}; 

Es tut mir Leid, dass der Code nicht so schön ist. (Es enthält einige Konsolenausgaben und Sachen zum Debuggen + einige out-kommentierte Objekte, die nicht mehr benutzt werden). Irgendwelche Vorschläge, warum mein Spiel nicht mehr funktioniert? Danke im Voraus!

Answer 1

Danke an nwp 3's Kommentar, ich habe es gelöst! Das Problem war in der Tat, dass mein Programm nach viel Ressourcen verlangte. Durch den Aufruf von "SDL_DestroyTexture (SDL_Texture * texture)" innerhalb meiner SpaceContainer-Klasse wurde das Problem behoben, wenn ein SpaceObject zerstört wurde!

SpaceContainer.cpp

#include "SpaceContainer.h" 

SpaceContainer::SpaceContainer(){} 

void SpaceContainer::checkLifetime(){ 
    if (vec.empty()) { 
     return; 
    } 
    for (size_t i = 0; i < vec.size(); i++) 
     { 
      if (vec[i].getDuration() >= vec[i].getTimeToLive()) { 

       //here was the issue!! 
       SDL_DestroyTexture(vec[i].getTexture()); 
       vec.erase(vec.begin() + i); 

      } 
     } 
} 

void SpaceContainer::popAt(int i) { 
    vec.erase(vec.begin() + i); 
} 

void SpaceContainer::pushBack(SpaceObject o) { 
    vec.push_back(o); 
} 

SpaceObject& SpaceContainer::getObject(int i) { 
    return vec.at(i); 
} 
std::vector<SpaceObject>& SpaceContainer::getVec() { 
    return vec; 
} 


size_t SpaceContainer::size(){ 
    return vec.size(); 
} 

SpaceContainer::~SpaceContainer(){}