重新初始化其父类时，SFML对象将不会绘制

Question

我正在开发一个新项目并实现一个基本的场景变化。 我将不同的场景设置为它们自己的类，使用初始化函数来创建和重新定位不同的SFML对象。 我看到了这个答案 ，同样也写了我的场景切换器：

// Create scene monitoring variable
int scene[2];
scene[0] = 0; // Set current scene to menu
scene[1] = 0; // Set scene change to no

...

// Check for scene change
if(scene[1] == 0) {
    // Run tick function based on current scene
    switch(scene[0]) {
        case 0:
            // Main menu - run tick function
            menu.tick();
    }
}
if(scene[1] == 1) {
    // Reset scene that you've changed to
    switch(scene[0]) {
        case 0:
            // Main menu - reset it
            menu = Menu(window, scene);    // <-- Reinitialise menu here
    }
    // Set change variable to 0
    scene[1] = 0;
}

您可以在github存储库中看到完整代码。

但是，这似乎不能正常工作 - 只要进行场景更改，屏幕就会变为空白。 该类被重新加入（我添加了一个cout来检查），仍然运行绘制功能，仍然处理鼠标点击，但窗口中没有任何内容。

我在这里做错了吗？

Answer 1

这样做会导致泄漏内存错误。 我建议你采用不同的方法： StateStack

这是怎么回事？

拥有StateStack对象的基础是将游戏/应用程序的每个可能状态存储到堆栈中。 这样，您可以按堆栈顺序处理每个。

什么是国家？

状态是可以更新 ， 绘制和处理事件的东西 。 我们可以创建一个接口或一个抽象类来使我们的屏幕表现得像一个状态。

哪个有优势？

使用堆栈结构，您可以轻松控制不同场景处理三种不同处理方法的方式。 例如。 如果您在暂停菜单中单击鼠标，则不会单击事件以达到菜单状态或“游戏”状态。 要实现这一点，解决方案非常简单，只需在handleEvent方法中返回false ，如果您不希望事件进一步发生此特定状态。 请注意，这个想法也可以扩展为draw或update方法。 在暂停菜单中，您不会update “游戏”状态。 在“游戏”状态下，您将不会draw游览菜单状态。

例

考虑到这一点，这是一种可行的实施方式。 一， State接口：

class State{
public:
    virtual bool update() = 0;
    virtual bool draw(sf::RenderTarget& target) const = 0;

    // We will use a vector instead a stack because we can iterate vectors (for drawing, update, etc)
    virtual bool handleEvent(sf::Event e, std::vector<State*> &stack) = 0;
};

在这个接口之后，我们可以有一个示例MenuState和PauseState ：

MenuState

class MenuState : public State{
public:
    MenuState(){
        m_count = 0;

        m_font.loadFromFile("Roboto-Regular.ttf");
        m_text.setFont(m_font);
        m_text.setString("MenuState: " + std::to_string(m_count));
        m_text.setPosition(10, 10);
        m_text.setFillColor(sf::Color::White);

    }

    virtual bool update() {
        m_count++;
        m_text.setString("MenuState: " + std::to_string(m_count));
        return true;
    }

    virtual bool draw(sf::RenderTarget &target) const{
        target.draw(m_text);
        return true;
    }

    virtual bool handleEvent(sf::Event e, std::vector<State*> &stack){
        if (e.type == sf::Event::KeyPressed){
            if (e.key.code == sf::Keyboard::P){
                stack.push_back(new PauseState());
                return true;
            }
        }
        return true;
    }

private:
    sf::Font m_font;
    sf::Text m_text;
    unsigned int m_count;
};

PauseState

class PauseState : public State{
public:
    PauseState(){
        sf::Font f;
        m_font.loadFromFile("Roboto-Regular.ttf");
        m_text.setFont(m_font);
        m_text.setString("PauseState");
        m_text.setPosition(10, 10);
        m_text.setFillColor(sf::Color::White);

    }

    virtual bool update() {
        // By returning false, we prevent States UNDER Pause to update too
        return false;
    }

    virtual bool draw(sf::RenderTarget &target) const{
        target.draw(m_text);
        // By returning false, we prevent States UNDER Pause to draw too
        return false;
    }

    virtual bool handleEvent(sf::Event e, std::vector<State*> &stack){
        if (e.type == sf::Event::KeyPressed){
            if (e.key.code == sf::Keyboard::Escape){
                stack.pop_back();
                return true;
            }
        }
        return false;
    }

private:
    sf::Font m_font;
    sf::Text m_text;
};

顺便说一下，当我这样做时，我注意到你必须将字体作为类的属性才能保留引用。 如果没有，当你的文字被绘制时，它的字体会丢失，然后失败。 另一种面对此问题的方法是使用资源持有者 ，这种资源持有者更有效，更强大。

说这个，我们的main看起来像：

主要

int main() {
    // Create window object
    sf::RenderWindow window(sf::VideoMode(720, 720), "OpenTMS");

    // Set window frame rate
    window.setFramerateLimit(60);

    std::vector<State*> stack;

    // Create menu
    stack.push_back(new MenuState());

    // Main window loops
    while (window.isOpen()) {
        // Create events object
        sf::Event event;
        // Loop through events
        while (window.pollEvent(event)) {
            // Close window
            if (event.type == sf::Event::Closed) {
                window.close();
            }

            handleEventStack(event, stack);
        }

        updateStack(stack);
        // Clear window
        window.clear(sf::Color::Black);
        drawStack(window, stack);
        // Display window contents
        window.display();
    }

    return 0;
}

堆栈函数是简单的for循环，但是细节向后迭代向量。 这是模仿堆栈行为的方法，从top（ size-1 index）开始到0结束。

堆栈功能

void handleEventStack(sf::Event e, std::vector<State*> &stack){
    for (int i = stack.size()-1; i >=0; --i){
        if (!stack[i]->handleEvent(e, stack)){
            break;
        }
    }
}

void updateStack(std::vector<State*> &stack){
    for (int i = stack.size() - 1; i >= 0; --i){
        if (!stack[i]->update()){
            break;
        }
    }
}

void drawStack(sf::RenderTarget &target, std::vector<State*> &stack){
    for (int i = stack.size() - 1; i >= 0; --i){
        if (!stack[i]->draw(target)){
            break;
        }
    }
}

您可以通过本书了解有关StateStacks和gamedev的更多信息