在游戏中使用状态模式

问题描述

最近，我尝试用SFML创建Snake游戏。但是，我也想使用一些设计模式来养成一些良好的习惯，以备将来编程时使用-状态模式。但是-有些问题我无法解决。

为使所有内容清晰明了，我尝试制作几个菜单-一个主菜单，其他菜单，例如“选项”或类似的东西。主菜单的第一个选项将使播放器进入“播放状态”。但是随后出现了问题-我认为整个游戏应该是一个独立的模块，可以实现编程。那么，我应该如何处理程序的实际状态呢？ （例如，我们将此状态称为“ MainMenu”）。

我是否应该附加一个名为“ PlayingState”的状态来代表整个游戏？我该怎么办？如何将新功能添加到单个状态？你有什么主意吗？

解决方法

例如，状态模式允许您拥有类Game的对象，并在游戏状态更改时改变其行为，从而提供了该Game对象已更改其类型的错觉。 / p>

例如，假设有一个具有初始菜单的游戏，如果您按下空格键可以暂停游戏。游戏暂停后，您可以按Backspace键返回到初始菜单，也可以再次按空格键继续播放：

首先，我们定义一个抽象类GameState：

struct GameState {
    virtual GameState* handleEvent(const sf::Event&) = 0;
    virtual void update(sf::Time) = 0;
    virtual void render() = 0;
    virtual ~GameState() = default; 
};

所有状态类（即MenuState，PlayingState，PausedState）将公开地从该GameState类派生。请注意，handleEvent()返回GameState *；这是为了提供状态之间的转换（即，如果发生转换，则为下一个状态）。

让我们暂时将重点放在Game类上。最终，我们的目的是按照以下方式使用Game类：

auto main() -> int {
   Game game;
   game.run();
}

也就是说，它基本上具有一个run()成员函数，该成员函数在游戏结束时返回。我们定义Game类：

class Game {
public:
   Game();
    void run();
private:
   sf::RenderWindow window_;

   MenuState menuState_;
   PausedState pausedState_;
   PlayingState playingState_;

   GameState *currentState_; // <-- delegate to the object pointed
};

此处的关键点是currentState_数据成员。在任何时候，currentState_都指向游戏的三种可能状态之一（即menuState_，pausedState_，playingState_）。

run()成员函数依赖于委托；它委派给currentState_所指向的对象：

void Game::run() {
   sf::Clock clock;

   while (window_.isOpen()) {
      // handle user-input
      sf::Event event;
      while (window_.pollEvent(event)) {
         GameState* nextState = currentState_->handleEvent(event);
         if (nextState) // must change state?
            currentState_ = nextState;
      }
     
      // update game world
      auto deltaTime = clock.restart();
      currentState_->update(deltaTime);

      currentState_->render();
   }
}

Game::run()调用GameState::handleEvent()，GameState::update()和GameState::render()成员函数，从GameState派生的每个具体类都必须重写。也就是说，Game没有实现用于处理事件，更新游戏状态和渲染的逻辑；它只是将这些责任委托给其数据成员GameState所指向的currentState_对象。通过这种委派，可以实现Game似乎在其内部状态更改时似乎会更改其类型的错觉。

现在，回到具体状态。我们定义PausedState类：

class PausedState: public GameState {
public:
   PausedState(MenuState& menuState,PlayingState& playingState):
      menuState_(menuState),playingState_(playingState) {}

    GameState* handleEvent(const sf::Event&) override;
    void update(sf::Time) override;
    void render() override;
private:
   MenuState& menuState_;
   PlayingState& playingState_;
};

PlayingState::handleEvent()必须在某个时候返回要转换为的下一个状态，这将对应于Game::menuState_或Game::playingState_。因此，此实现包含对MenuState和PlayingState对象的引用；它们将被设置为指向Game::menuState_构造中的Game::playingState_和PlayState数据成员。另外，当游戏暂停时，理想情况下，我们希望以与游戏状态相对应的屏幕为起点，如下所示。

PauseState::update()的实现包括什么都不做，游戏世界完全一样：

void PausedState::update(sf::Time) { /* do nothing */ }

PausedState::handleEvent()仅对按下空格键或退格键的事件作出反应：

GameState* PausedState::handleEvent(const sf::Event& event) {
   if (event.type == sf::Event::KeyPressed) {

      if (event.key.code == sf::Keyboard::Space)
         return &playingState_; // change to playing state

      if (event.key.code == sf::Keyboard::Backspace) {
         playingState_.reset(); // clear the play state
         return &menuState_; // change to menu state
      }
   }
   // remain in the current state
   return nullptr; // no transition
}

PlayingState::reset()用于在构建后将PlayingState清除为其初始状态，因为我们在开始播放之前返回到初始菜单。

最后，我们定义PausedState::render()：

void PausedState::render() {
   // render the PlayingState screen
   playingState_.render();

   // render a whole window rectangle
   // ...

   // write the text "Paused"
   // ...
}

首先，此成员函数呈现与播放状态相对应的屏幕。然后，在播放状态的此渲染屏幕上方，它渲染一个具有透明背景的矩形，该矩形适合整个窗口。这样，我们使屏幕变暗。在此渲染矩形的顶部，它可以渲染类似“暂停”文本的内容。

一堆状态

另一种体系结构由状态栈组成：状态堆叠在其他状态之上。例如，暂停状态将位于播放状态之上。事件从最高状态传递到最低状态，因此状态也被更新。从底部到顶部执行渲染。

可以将这种变体视为上述情况的概括，因为作为特殊情况，您总是可以拥有仅由一个状态对象组成的堆栈，并且这种情况将与普通的状态模式相对应。

如果您有兴趣了解有关此其他体系结构的更多信息，建议阅读本书SFML Game Development的第五章。

,

对于您的设计，我认为您可以为不同的状态使用增量循环：

简单的例子：

// main loop
while (window.isOpen()) {
    // I tink you can simplify this "if tree"
    if (state == "MainMenu")
        state = run_main_menu(/* args */);
    else if (state == "Play")
        state = run_game(/* args */);
    // Other state here
    else
        // error state unknow
        // exit the app
}

游戏运行时：

state run_game(/* args */)
{
    // loading texture,sprite,...
    // or they was passe in args

    while (window.isOpen()) {
        while (window.pollEvent(event)) {
            // checking event for your game
        }
        // maybe modifying the state
        // Display your game
        // Going to the end game menu if the player win/loose
        if (state == "End")
            return run_end_menu(/* args */);
            // returning the new state,certainly MainMenu
        else if (state != "Play")
            return state;
    }
}

您有一个主菜单和一个游戏，默认状态为"MainMenu"。

进入主菜单后，单击播放按钮，然后状态返回"Play"，然后返回主循环。

状态为"Play"，因此您可以进入游戏菜单并开始游戏。

游戏结束时，您将状态更改为"EndGame"，然后从游戏菜单移至结束菜单。

结束菜单返回要显示的新菜单，因此您返回主循环并检查每个可用菜单。

通过这种设计，您可以添加新菜单而无需更改整个体系结构。