XNA Game Engine Tutorial Series #4 – DrawOrder

// The draw order of the component. Lower values draw first
int drawOrder = 1;
 
// Draw order changed event
public event ComponentDrawOrderChangedEventHandler DrawOrderChanged;
 
// Public draw order. If the value is changed, we fire the draw
// order change event
public int DrawOrder
{
    get { return drawOrder;}
    set
    {
        // Save a copy of the old value and set the new one
        int last = drawOrder;
        drawOrder = value;
 
        // Fire DrawOrderChanged
        if (DrawOrderChanged != null)
            DrawOrderChanged(this, 
                new ComponentDrawOrderChangedEventArgs(
                    this, last, this.Parent.Components));
    }
}

// Event arguments for draw order change on a component
public class ComponentDrawOrderChangedEventArgs : EventArgs
{
    // Component that was modified
    public Component Component;
 
    // The old draw order
    public int LastDrawOrder;
 
    // The collection that owns the component
    public ComponentCollection ParentCollection;
 
    public ComponentDrawOrderChangedEventArgs(Component Component, 
        int LastDrawOrder, ComponentCollection ParentCollection)
    {
        this.Component = Component;
        this.LastDrawOrder = LastDrawOrder;
        this.ParentCollection = ParentCollection;
    }
}
 
// Event handler for draw order change on a component
public delegate void ComponentDrawOrderChangedEventHandler(
    object sender, ComponentDrawOrderChangedEventArgs e);

using System.Collections;
using System.Collections.Generic;
 
namespace Innovation
{
    public class ComponentEnumerator : IEnumerator
    {
        // The current position
        int position = -1;
 
        // The collection we are enumerating
        ComponentCollection collection;
 
        // The order in which to return items from 'collection'
        List<int> ordered = new List<int>();
 
        // The current item, which is the item who's index is
        // at the current position in the order list
        public object Current 
        { 
            get { return collection[ordered[position]]; } 
        }
 
        // Constructor sets the local component list and order
        public ComponentEnumerator(ComponentCollection Collection,
            List<int> Order)
        {
            this.collection = Collection;
            this.ordered = Order;
        }
 
        // Moves to the next item in the list
        public bool MoveNext()
        {
            position++;
 
            // If we have reached the end of the list, stop
            // enumerating
            if (position == ordered.Count)
                return false;
 
            // Otherwise keep going
            return true;
        }
 
        public IEnumerator GetEnumerator()
        {
            return this;
        }
 
        // Resets to the beginning of the list
        public void Reset()
        {
            position = -1;
        }
    }
}

using System.Collections.Generic;
using System.Collections.ObjectModel;
 
namespace Innovation
{
    // A custom collection for managing components in a GameScreen
    public class ComponentCollection : Collection<Component>
    {
        // The GameScreen to manage components for
        GameScreen owner;
 
        // The list containing each component's index in the
        // component list, in the order we want them to draw
        List<int> inDrawOrder = new List<int>();
 
        // Constructor
        public ComponentCollection(GameScreen Owner)
        {
            owner = Owner;
        }
 
        // Override InsertItem so we can set the parent of the
        // component to the owner and manage the DrawOrder
        protected override void InsertItem(int index, Component item)
        {
            // Remove component from it's parent's list
            if (item.Parent != null && item.Parent != owner)
                item.Parent.Components.Remove(item);
 
            // Set the new parent
            item.Parent = owner;
 
            // Tell what to do when the item's draw order changes
            item.DrawOrderChanged += new ComponentDrawOrderChangedEventHandler(ComponentDrawOrderChangeEventHandler);
 
            base.InsertItem(index, item);
 
            // Update its position in the draw order list
            UpdateDrawPosition(item);
        }
 
        // Draw order changed event handler
        void ComponentDrawOrderChangeEventHandler(object sender, ComponentDrawOrderChangedEventArgs e)
        {
            // We simply update the component's position using the
            // existing method
            UpdateDrawPosition(e.Component);
        }
 
        // Updates the position of the component in the draw order list
        void UpdateDrawPosition(Component Component)
        {
            // Save the draw order and index location in the component list
            int ord = Component.DrawOrder;
            int loc = Items.IndexOf(Component);
 
            // Remove the index from the in order list
            if (inDrawOrder.Contains(loc))
                inDrawOrder.Remove(loc);
 
            // Create our index variable
            int i = 0;
 
            // Search through the ordered list until we find a component of
            // lesser or equal draw order value
            if (ord > 0)
            {
                while (i < inDrawOrder.Count)
                    // If the current item's draw order is greator or
                    // equal to the one we are working with...
                    if (Items[inDrawOrder[i]].DrawOrder >= ord)
                    {
                        // If it is greator, decrement it so it is
                        // above the component we are moving's draw order...
                        if (Items[inDrawOrder[i]].DrawOrder > ord)
                            i--;
 
                        // And stop looping
                        break;
                    }
                    // Otherwise, keep going (until we reach the end of the
                    // list)
                    else
                        i++;
            }
 
            // Insert the location of the component in the component list
            // into the ordered list
            inDrawOrder.Insert(i, Items.IndexOf(Component));
        }
 
        // Tells what enumerator to use when we want to loop through
        // components by draw order
        public ComponentEnumerator InDrawOrder
        {
            get { return new ComponentEnumerator(this, inDrawOrder); }
        }
 
        // Override RemoveItem so we can set the parent of
        // the component to null (no parent)
        protected override void RemoveItem(int index)
        {
            Items[index].Parent = null;
 
            // Unhook the draw order change event
            Items[index].DrawOrderChanged -= ComponentDrawOrderChangeEventHandler;
 
            // Remove the component from the collection
            base.RemoveItem(index);
 
            // Rebuild inDrawOrder
            inDrawOrder.Clear();
            foreach (Component component in Items)
                UpdateDrawPosition(component);
        }
    }
}

foreach (Component component in Components)

foreach (Component component in Components.InDrawOrder)

ClearScreen clr = new ClearScreen();

ClearScreen clr = new ClearScreen();
actor.DrawOrder = 2;