Seperation of game- and rendering logic

Question

What is the best way to seperate rendering code from the actually game engine/logic code? And is it even a good idea to seperate those?

Let's assume we have a game object called Knight. The Knight has to be rendered on the screen for the user to see. We're now left with two choices. Either we give the Knight a Render/Draw method that we can call, or we create a renderer class that takes care of rendering all knights.

In the scenario where the two is seperated the Knight should the knight still contain all the information needed to render him, or should this be seperated as well?

In the last project we created we decided to let all the information required to render an object be stored inside the object itself, but we had a seperate component to actually read those informations and render the objects. The object would contain information such as size, rotation, scale, and which animation was currently playing and based on this the renderer object would compose the screen.

Frameworks such as XNA seem to think joining the object and rendering is a good idea, but we're afraid to get tied up to a specific rendering framework, whereas building a seperate rendering component gives us more freedom to change framework at any given time.

Answer 1

I would create a separate KnightRenderer class. Advantages:

• Clean separation between the game logic and the rendering. The Knight himself might even run on a game server and not know anything about rendering at all.
• Smaller, simpler classes, concerned with one and only one piece of functionality.

Everything the KnightRenderer needs to know about the Knight (position, status) has to be publically readable in Knight.

Properties specific to rendering would go into the KnightRenderer class. For example, maybe you want to make the knight flash when he's hit, so you would need to store a counter or time value.

Answer 2

I would endeavor to make your objects as generic as feasible and to avoid encoding gameplay facts into your code as much as possible.

E.g. you have an Entity or Object or Actor class, and that class has a pointer to its decision making (its AI) and a pointer to its graphical representation.

Its decision making is necessarily coupled to the gameplay facts; indeed it is a part of gameplay facts. So this is somewhere where you might name your decision maker "KnightAi" or something.

On the other hand, the graphical representation is just a bit of graphics. It'll be drawn the same as every other entity. You have a model or some bitmaps and some animations or not... This would/could just be called something like "Model" and will load the information that it's told to load the defines what the entity looks like to the player. When it comes to rendering your knight versus your horse versus a castle, you'll likely find that they all do the same thing just with different data. The sorts of data that they have is even all the same, it's just the contents that are different.

Say your entities were all represented as circles. You would just have them point to a CircleRenderer that took the size that they should be drawn. You wouldn't create a different renderer class for each different size (or color, or whatever) of circle you wanted!