Game screen management

I am working on a screen manager for a miniature game engine, and so far I cannot find a proper solution to managing screen objects without using the 'blob' for each one of the screens. Is blob tolerable in such circumstances where I need a list of renderable objects in one controlle开发者_Go百科r?

I would consider using the MVC pattern in this situation. Otherwise, if you're not careful, it's very easy to end up with a bunch of spaghetti code where the screen code is reaching into the game code, and vice versa.

I have recently coded something you might call a "screen manager".

I started with the idea that, whatever game I make, the render system is going to be pretty much the same in terms of how to render (how to manage the hardware). The thing that changes is what is rendered, and how to draw it (do I want a box or a circle or a bitmap.. representing what... etc).

So basically the "game state" is responsible for knowing how to render itself, and should do so when given a render surface from the screen manager or graphics system (It should also be responsible for other things like knowing how input, physics, etc act upon itself).

I implemented it with a singleton for the GraphicsSystem object, which was called something like this:

GameState gs;
Graphics::System().Init(DOUBLE_BUFFER, 640, 480);
...
while(still_looping) {
    ...
    // When it is time to render:
    Graphics::System().RenderGameState(&gs);
}

And how, you ask, does the Graphics::System() singleton know how to render the game state? It knows because the game state is inherited from a listener exposed by the graphics system...

//within GraphicsSystem.h...
class BaseRenderer
{
public:
    virtual void Render(BITMAP *render_surface) = 0;
};

//GameState defined with:
class GameState : public BaseRenderer
{
public:
    void Render(BITMAP *render_surface);
    ...

You can do this with nearly all the subsystems... (probably not timing, as it is needed in the game loop).

Why singletons? Well, it is C++ and I'm assuming there is only 1 screen, or graphics subsystem to render with. I'm not sure if you are using multiple screens, or a mobile phone or a console. The other way I would do it is to have the graphics system as static global variables in a separate file, giving them file scope only, and having accessor functions in that file (my old C way of doing things).

The key though is encapsulation. Let your screen manager manage the hardware. Let your game state dictate how itself should be expressed.

If this misses the point, please clear up your question and I can edit the answer.