How to simplify game loop with multiple classes - c++

Question

For my current project I have several classes defining levels for the game. All of the levels are of the following form:
class Level1
{
public:
Level1(int initialFrame);
void update(int frameCount, sf::RenderWindow* renderWindow);
void draw(sf::renderWindow* renderWindow);
bool finished;
};
Note that none of the definitions for the functions update and draw are the same between levels.
In main my loop looks something like this:
int main()
{
sf::RenderWindow renderWindow();
frames = 0;
progress = 0;
Level1* level1 = new Level1(0);
Level2* level2 = 0;
Level3* level3 = 0;
while (true) // Not actually like this, just put it here to illustrate my point
{
renderWindow.clear()
if (progress == 0)
{
level1->update(frames, &renderWindow)
level1->draw(&renderWindow)
if (level1->finished)
{
delete level1;
progress++;
level2 = new level2(frames);
}
}
if (progress == 1)
{
level2->update(frames, &renderWindow)
level2->draw(&renderWindow)
if (level2->finished)
{
delete level2;
progress++;
level3 = new level3(frames);
}
}
if (progress == 2)
{
level3->update(frames, &renderWindow)
level3->draw(&renderWindow)
if (level3->finished)
{
delete level3;
progress++;
}
}
frames++;
renderWindow.display();
}
}
So I wanted to simplify this as I have the similar blocks of code running over and over. To solve this I created a template as such:
template <class T>
void loop(T level, int frameCount, sf::RenderWindow* renderWindow, int* progress)
{
level->update(frameCount, renderWindow);
level->draw(renderWindow);
if (level->finished)
{
delete level;
*progress++;
}
}
This partly works, but I'm stuck on how to, a) Initialise the next level when one is finished in the template, and b) how to implement the template function in my game loop without using a check for progress, and manually programming in each level like I had before. Ideally I'd want something like a list of levels in the order I want them to be played, and progress could index which one I'm using the loop on, but I'm not sure how to implement that.

Answer 1

You should make a abstract base class of level:
class Level
{
public:
Level(int initialFrame);
virtual ~Level();
virtual void update(int frameCount, sf::RenderWindow* renderWindow) = 0;
virtual void draw(sf::renderWindow* renderWindow) = 0;
bool finished;
};
and let all your levels inherit from this class:
class Level1 : public Level
{
public:
Level1(int initialFrame);
void update(int frameCount, sf::RenderWindow* renderWindow) override;
void draw(sf::renderWindow* renderWindow) override;
};
And then just swap between them depending on the current progress.
Level* currentLevel = new Level1(0);
...
while (true)
{
currentLevel->update(frames, &renderWindow)
currentLevel->draw(&renderWindow)
if (currentLevel->finished)
{
delete currentLevel;
progress++;
switch(progress)
{
case 1: currentLevel = new Level2(...); break;
case 2: currentLevel = new Level3(...); break;
case 3: currentLevel = new Level4(...); break;
...
}
}
So you save yourself some if-blocks.

Answer 2

You're overthinking this.
Define a Level interface which is implemented by all your levels
class Level {
public:
virtual void update(int frameCount, sf::RenderWindow* renderWindow) = 0;
virtual void draw(sf::renderWindow* renderWindow) = 0;
virtual bool finished() = 0;
};
Then simply create a queue of levels and pop from it
auto Levels = std::queue<std::unique_ptr<Level>>();
Levels.push(std::make_unique<Level1>());
Levels.push(std::make_unique<Level2>());
Levels.push(std::make_unique<Level3>());
std::unique_ptr<Level> currentLevel = Levels.front();
Levels.pop();
while(true){
if(currentLevel->finished()){
if(Levels.empty()){
break;
currentLevel = std::move(Levels.front())
Levels.pop();
}
currentLevel->update(frames, &renderWindow)
currentLevel->draw(&renderWindow);
frames++;
renderWindow->display();
}
If you absolutely need to pass in the frames at construction time, or you don't want to allocate the memory ahead of time, you could make a list of functionals instead, where the function returns a std::unique_ptr<Level>.