Architecture logicielle & Développement

Function Layer

Context

A game screen is built using a large number of operations.

Problem

When building a game screen, the management of the different entities that need to be updated and/or displayed is more and more complex. Subttle bugs occur. It is difficult to maintain the correct execution of the different operations that are needed to build the game screen. You may want to change the order in which operations are executed but doing so has a large impact on the code.

Forces

1. Game screens are often built from separate operations (main game representation, HUD, GUI etc).
2. It is desirable to have separate code for separate operations.
3. The code of a particular operation can rely on the execution of another operation.
4. On the contrary, the code of a particular operation can be independent of the code for all other operations.
5. If the code of these operations is not carefully designed, major maintenance problems will happen.
6. Adding or removing a particular operation may have consequences on other unrelated operations.
7. Modifying the state of a particular operation may have some impact on other unrelated operations.

Solution

Transform the operation into a set of function objects. Arrange these functions into an sorted list, and run through the list to create the game frame. The order in which you run through the list depends on your goal - the function update order can differ from the drawing update order.

Consequences

• You break down the game screen into smaller entities that can be easily used (force 1, 2, 5).
• The ordering of operations is easier to control (force 3)
• You allow the programmer to manage the different functions independently (force 4, 7).
• Addition and removal of operations is simple (force 6).

Structure

The calling program creates concrete layer instances and add them to the layer collection. When it calls LayerCollection::Function(), the layers are sorted following a programmer-specified order and their Layer::Function() are called in sequence.

Here is a sample LayerCollection::Function():

void LayerCollection::Function()
{
   this->Sort();

   for (IteratorType it = list.begin(); it != list.end(); ++it)
   {
     it->Function();
   }
}

Known usage^[1]

This pattern has its roots in the design of the XNA game components, thus every XNA game that use them also use this pattern to some extent. Additionally, games that display some kind of HUD - or any kind of graphical user interface on the top of the game screen - would benefits of the Function Layer pattern.

Taxonomy and relation to other patterns

The Function Layer is an behavioral pattern that operates on objects^[2]. It uses the Strategy pattern to implement layers and the Iterator pattern^[3] to iterate through the layer list.