Add a new class to your engine’s project, and this time call it “GameScreen”. Once again we can remove some of the “using” statements, until we are left with the following.

using System;
using System.Collections.Generic;

namespace InnovationEngine
{
    public class GameScreen
    {
    }
}

As GameScreen is in charge of managing a set of components, the first thing we need to add is a list of components.

List<Component> components = new List<Component>();

The “<” and “>” and the type between them signify the type of list we want to create. As the List class is designed to work with any type of object, we must specify what type of object we want this list to work with. This is called a “generic” argument, and you will find that many classes use them; in fact some of our classes will also use them later on.

We should probably start by providing a way for components to be added to the GameScreen. The method below does just that. You will note that it first checks if the component is already in the list, as we will run into issues if a component is added more than once. If the component is a new one, it will add it to the list and also set the GameScreen as the component’s “Parent”. We haven’t added this property to the Component class yet, but we will in a moment.

public void AddComponent(Component Component)
{
    if (!components.Contains(Component))
    {
        components.Add(Component);
        Component.Parent = this;
    }
}

We also want to provide a way for external code to access the list of components. We will do this similarly to the way you access items in an array, using the [] and index, except here we will use a string as the index instead of an integer.

// Allow for components to be retrieved with the [] index, ie:
// Component c = gameScreenInstance["Component1"];
public Component this[string Name]
{
    get
    {
        foreach (Component component in components)
            if (component.Name == Name)
                return component;

        return null;
    }
}

We also want to provide a way to remove components from the screen. We will actually be providing two functions that do this. One takes the component itself as an argument, while the other takes the name of the component. The second function actually just retrieves the component using the index functionality we just added, then calls the second function using that component as an argument.

public void RemoveComponent(string Name)
{
    Component c = this[Name];
    RemoveComponent(c);
}

public void RemoveComponent(Component Component)
{
    if (Component != null && components.Contains(Component))
    {
        components.Remove(Component);
        Component.Parent = null;
    }
}

The last two functions we need to provide are the Update and Draw functions. These two functions simply loop through the list of components, and call Update and Draw on each of them. There is one caveat here, though, which is that components may be added or removed from the screen during this update. What happens if the list of components is modified while we are looping through it? Well, the list will through an exception, and the game will crash. To avoid this problem we first copy the list before iterating through it in the Update function. You will note that we once again made these functions “virtual”, so that classes that build on top of the GameScreen will be able to add their own code to them.

public virtual void Update()
{
    // Copy the list of components so the game won't crash if the original
    // is modified while updating
    List<Component> updating = new List<Component>();

    foreach (Component c in components)
        updating.Add(c);

    foreach (Component c in updating)
        c.Update();
}

public virtual void Draw()
{
    foreach (Component c in components)
        c.Draw();
}

To finish this all off, we need to add the Parent property mensioned earlier to the Component class. Notice that there are some extra checks in the “set” portion of the property to make sure that the parent variable is only changed if it is not set to the new value already. This avoids an infinite loop: as we want to be able to either set the parent on the component directly, or use the AddComponent method on the GameScreen, we need to always be sure to notify either the GameScreen if a component has set it as its parent, or the Component if it has been added to a GameScreen. However, notifying one of them will cause them to notify the other again, and they will continuously let eachother know about their new affiliation until the game runs out of memory and crashes. To avoid this, we make sure that we are not notifying the parent GameScreen unless there is actually a change in parents happening.

GameScreen parent;

public GameScreen Parent
{
    get { return parent; }
    set
    {
        if (parent == value)
            return;

        if (parent != null)
            parent.RemoveComponent(this);

        parent = value;

        if (value != null)
            parent.AddComponent(this);
    }
}

Download the Code for this Chapter