XNA Game Engine教程系列1-Component和GameScreen

using Microsoft.Xna.Framework;

namespace Innovation

{

public class Component

{

// The GameScreen object that owns this component

public GameScreen Parent;

// Whether or not this component has been initialized

public bool Initialized = false;

// Whether or not the GameScreen that owns the component

// should draw it

public bool Visible = true;

// This overloaded constructor allows us to specify the parent

public Component(GameScreen Parent)

{

InitializeComponent(Parent);

}

// This overload allows will set the parent to the default

// GameScreen

public Component()

{

InitializeComponent(Engine.DefaultScreen);

}

// This is called by the constructor to initialize the

// component. This allows us to only have to override this

// method instead of both constructors

protected virtual void InitializeComponent(GameScreen Parent)

{

// Check if the engine has been initialized before setting

// up the component, or the Engine will crash when the

// component tries to add itself to the list.

if (!Engine.IsInitialized)

throw new Exception("Engine must be initialized with \"SetupEngine()\"" + "before components can be initialized");

Parent.Components.Add(this);

Initialized = true; }

// Updates the component - This is called by the owner

public virtual void Update()

{

} // Draws the component - This is called by the owner

public virtual void Draw() { }

// Unregisters the component with its parent

public virtual void DisableComponent()

{

Parent.Components.Remove(this);

}

}

}

using Microsoft.Xna.Framework;

namespace Innovation

{

// Represents a 3D object. These objects will be drawn before

// 2D objects, and will have modifiers automatically provided

// in the editor.

public interface I3DComponent

{

// Position in the Cartesian system (X, Y, Z)

Vector3 Position { get; set; }

// Rotation represented as a Vector3. This shouldn't

// be used for calculations, it is left in so that

// the rotation can be more easily modified by hand

Vector3 EulerRotation { get; set; }

// Rotation as a Matrix. This will give much smoother

// and cleaner calculations that a

Vector3 Matrix Rotation { get; set; }

// Scale for each axis (X, Y, Z)

Vector3 Scale { get; set; }

// BoundingBox to use for picking and pre-collision

BoundingBox BoundingBox { get; } }

// Represents a 2D object. These objects will be drawn after

// 3D objects, and will have modifiers automatically provided

// in the editor.

public interface I2DComponent {

Rectangle Rectangle { get; set; } }

public enum ComponentType

{

// Represents all 2D components (I2DComponent)

Component2D,

// Represents all 3D components (I3DComponent)

Component3D,

// Represents all components that are either 2D or 3D

// components

Both,

// Represents all components regardless of type

All

}

}

using System;

using System.Collections.Generic;

using System.Linq; using System.Text;

namespace Innovation

{

public class GameScreen

{

// Keep track of all the components we need to manage

public ComponentCollection Components;

// Whether or not to draw

public bool Visible = true;

// Whether or not this screen should block the update of

// screens below (for pause menus), etc. public

bool BlocksUpdate = false;

// Whether or not this screen can override a blocked update

// from an above screen (for a background screen), etc.

public bool OverrideUpdateBlocked = false;

// Same for drawing public

bool BlocksDraw = false;

// Same for drawing public

bool OverrideDrawBlocked = false;

// Same for input public

bool BlocksInput = false;

// Same for input public bool OverrideInputBlocked = false;

// Whether or not we want to block our own input so we can

// do things like loading screens that will want to accept

// input at some point, but not at startup

public bool InputDisabled = false;

// This is set by the engine to tell us whether or not input

// is allowed. We can still get input, but we shouldn't. This

// is useful because a ProcessInput() type of function would

// make it hard to manage input (because we can't utilize // events, etc.)

public bool IsInputAllowed = true;

// The name of our component, set in the constructor. This

// is used by the Engine, because a GameScreen can be accessed

// by name from Engine.GameScreens[Name].

public string Name;

// Fired when the component's Initialize() is finished. This can

// be hooked for things like asynchronous loading screens public event EventHandler OnInitialized;

// Whether or not the component is initialized. Handles firing of

// OnInitialized.

bool inititalized = false;

public bool Initialized {

get { return inititalized; }

set { inititalized = value;

if (OnInitialized != null)

{

// Fire the OnInitalized event to let other's know we

// are done initializing OnInitialized(this, new EventArgs());

}

}

}

// Constructor takes the name of the component

public GameScreen(string Name)

{ // Setup our component collection

Components = new ComponentCollection(this);

// Register with the engine and set our name

this.Name = Name;

Engine.GameScreens.Add(this);

// Initialize the component

if (!Initialized)

Initialize();

}

// Overridable function to initialize the GameScreen

public virtual void Initialize()

{

this.Initialized = true;

}

// Update the screen and child Components

public virtual void Update()

{

// Create a temporary list so we don't crash if

/ a component is added to the collection while

// updating

List updating = new List();

// Populate the temporary list

foreach (Component c in Components)

updating.Add(c);

// Update all components that have been initialized

foreach (Component Component in updating)

if (Component.Initialized)

Component.Update();

}

// Draw the screen and its components. Accepts a ComponentType

// to tell us what kind of components to draw. Either 2D, 3D, or

// both. (Useful for drawing a reflection into a render target

// without 2D components getting in the way)

public virtual void Draw(ComponentType RenderType)

{

// Temporary list

List drawing = new List();

foreach (Component component in Components)

{

if (RenderType == ComponentType.Both)

{

// If the render type is both, we will draw all 2D or

// 3D components

if (component is I2DComponent || component is I3DComponent)

drawing.Add(component);

}

else if (RenderType == ComponentType.Component2D)

{

// If the render type is 2D, we will only draw 2D

// components

if (component is I2DComponent)

drawing.Add(component);

}

else if (RenderType == ComponentType.Component3D)

{

// If the render type is 2D, we will only draw 3D

// components

if (component is I3DComponent)

drawing.Add(component);

}

else

{

// Otherwise, we will draw every component regardless of type

drawing.Add(component);

}

}

// Keep a list of components that are 2D so we can draw them on top

// of the 3D components

List defer2D = new List();

foreach (Component component in drawing)

if (component.Visible && component.Initialized)

{

// If the component is visible and is not loading itself..

if (component is I2DComponent) {

// If it is 2D, wait to draw

defer2D.Add(component);

} else

{

// otherwise, draw immediately

component.Draw();

}

} // Draw 2D components

foreach (Component component in defer2D)

component.Draw();

}

// Disables the GameScreen

public virtual void Disable() {

// Clear out our components

Components.Clear();

// Unregister from the Engine's list

Engine.GameScreens.Remove(this);

// If the engine happens to have this screen set as the default

// screen, set it to the background screen in the Engine class

if (Engine.DefaultScreen == this)

Engine.DefaultScreen = Engine.BackgroundScreen;

}

// Override ToString() to return our name

public override string ToString()

{

return Name;

}

}

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Collections.ObjectModel;

namespace Innovation

{

// A custom collection for managing components in a GameScreen

public class ComponentCollection : Collection

{

// The GameScreen to manage components for GameScreen owner;

public ComponentCollection(GameScreen Owner)

{ owner = Owner; }

// Override InsertItem so we can set the parent of the

// component to the owner

protected override void InsertItem(int index, Component item)

{

if (item.Parent != null && item.Parent != owner)

item.Parent.Components.Remove(item);

item.Parent = owner;

base.InsertItem(index, item);

}

// Override RemoveItem so we can set the paren of

// the component to null (no parent)

protected override void RemoveItem(int index)

{

Items[index].Parent = null;

base.RemoveItem(index);

}

}

}