XNA Game Engine教程系列2- Engine, Content和Services
-
在这一章中，我们要创建游戏引擎的主类。首先新添一个文件“Engine.cs”到文件夹“Components”中，然后加入以下代码以创建一个静态类“Engine”。这个类与前面我们创建的其他类的区别是它不需要实例化（使用“new ObjectType ();”），这里我们使用“Engine.MemberName”获取其成员。以下是是开始代码：
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
namespace Innovation
{
public static class Engine { }
}
接着我们要添加一些成员变量到Engine类中。
// The GraphicsDevice the engine is using
public static GraphicsDevice GraphicsDevice;
// The Engine's SpriteBatch
public static SpriteBatch SpriteBatch;
// The collection of GameScreens we are managinng
public static GameScreenCollection GameScreens = new GameScreenCollection();
// The current GameTime
public static GameTime GameTime;
// Whether the Engine has been initialized yet
public static bool IsInitialized = false;
下一步我们要创建一个方法来初始化引擎。这个方法接受IgraphicsDeviceService对象以帮助我们建立引擎的graphics。如果是从Game类初始化的话，这个graphics就是在默认游戏模板中创建的GraphicsDeviceManager graphics。下面是initialize方法：
// Initializes the engine
public static void SetupEngine(IGraphicsDeviceService GraphicsDeviceService)
{
// Setup the GraphicsDevice and SpriteBatch
Engine.GraphicsDevice = GraphicsDeviceService.GraphicsDevice;
Engine.SpriteBatch = new SpriteBatch(GraphicsDeviceService.GraphicsDevice);
Engine.IsInitialized = true;
}
下一个我们需要的方法是update方法。这将更新所有的GameScreens，而GameScreens更新包含其中的组件。更新和绘制的逻辑有点复杂，因为screen可以互相阻止绘制和更新。update接受GameTime用来更新内部的GameTime，Draw方法也一样。
// Update the engine, screens, and components
public static void Update(GameTime gameTime)
{
// Update the game time
Engine.GameTime = gameTime;
// Create a temporary list
List updating = new List();
// Populate the temp list
foreach (GameScreen screen in GameScreens)
updating.Add(screen);
// BlocksUpdate and OverrideUpdateBlocked login
for (int i = GameScreens.Count - 1; i >= 0; i--)
if (GameScreens[i].BlocksUpdate)
{
if (i > 0)
for (int j = i - 1; j >= 0; j--)
if (!GameScreens[j].OverrideUpdateBlocked)
updating.Remove(GameScreens[j]);
break;
} // Update remaining components
foreach (GameScreen screen in updating)
if (screen.Initialized)
screen.Update();
// Clear list
updating.Clear();
// Repopulate list
foreach (GameScreen screen in GameScreens)
updating.Add(screen);
// BlocksInput and OverrideInputBlocked login
for (int i = GameScreens.Count - 1; i >= 0; i--)
if (GameScreens[i].BlocksInput) { if (i > 0)
for (int j = i - 1; j >= 0; j--)
if (!GameScreens[j].OverrideInputBlocked)
updating.Remove(GameScreens[j]);
break;
}
// Set IsInputAllowed for all GameScreens
foreach (GameScreen screen in GameScreens)
if (!screen.InputDisabled)
screen.IsInputAllowed = updating.Contains(screen);
else
screen.IsInputAllowed = false;
}
draw方法非常相似，我们为BlocksDraw和组件做了一些逻辑，然后我们绘制它们。
// Draws the current collection of screens and components. Accepts a
// ComponentType to render
public static void Draw(GameTime gameTime, ComponentType RenderType)
{
// Update the time, create a temp list
Engine.GameTime = gameTime;
List drawing = new List();
// Clear the back buffer
GraphicsDevice.Clear(Color.CornflowerBlue);
// Populate the temp list if the screen is visible
foreach (GameScreen screen in GameScreens)
if (screen.Visible)
drawing.Add(screen);
// BlocksDraw and OverrideDrawBlocked logic
for (int i = GameScreens.Count - 1; i >= 0; i--)
if (GameScreens[i].BlocksDraw)
{
if (i > 0)
for (int j = i - 1; j >= 0; j--)
{
if (!GameScreens[j].OverrideDrawBlocked)
drawing.Remove(GameScreens[j]);
}
break;
}
// Draw the remaining screens
foreach (GameScreen screen in drawing)
if (screen.Initialized)
screen.Draw(RenderType);
}
下一步我们将添加一个IServiceContainer对象。这个对象将追踪叫做Service Providers的对象。我们可以根据类型检索和存储Service Providers。例如，为了获得GraphicsDeviceService，我们将使用“Engine.Services.GetService（typeof （IGraphicsDeviceService));”。或者，为了存储叫做“content”的ContentManager对象，我们使用“Engine.Services.AddService（typeof（ContentManager），content）;”。我们将创建一个继承自IserviceContainer的类，其中包含了添加，删除并获得服务的方法。以下是代码：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Xna.Framework;
namespace Innovation
{
public class IEServiceContainer : IServiceProvider
{
// Contains the service types and services Dictionary services = new Dictionary(); // Add a new service public void AddService(Type Service, object Provider)
{ // If we already have this type of service provider, throw an
// exception if (services.ContainsKey(Service)) throw new Exception("The service container already has a " + "service provider of type " + Service.Name); // Otherwise, add it to the list this.services.Add(Service, Provider); }
// Get a service from the service container public object GetService(Type Service) {
// If we have this type of service, return it foreach (Type type in services.Keys) if (type == Service) return services[type];
// Otherwise, throw an exception throw new Exception("The service container does not contain " + "a service provider of type " + Service.Name); } // A shortcut way to get a service. The benefit here is that we
// can specify the type in the brackets and also return the // service of that type. For example, instead of
// "Camera cam = (Camera)Services.GetService(typeof(Camera));", // we can use "Camera cam = Services.GetService()" public T GetService() { object result = GetService(typeof(T)); if (result != null) return (T)result; return default(T); } // Removes a service provider from the container public void RemoveService(Type Service) { if (services.ContainsKey(Service)) services.Remove(Service); } // Gets whether or not the container has a provider of this type public bool ContainsService(Type Service) { return services.ContainsKey(Service); } } }
现在，我们需要在Engine类中建立一个实例。在Engine类顶部添加以下代码：
// The engine's service container public static IEServiceContainer Services;
和在SetupEngine（）方法中添加以下代码：
// Setup the service container and add the IGraphicsDeviceService to it Engine.Services = new IEServiceContainer(); Engine.Services.AddService(typeof(IGraphicsDeviceService), GraphicsDeviceService);
现在我们要创建一个自定义ContentManager并将其添加到Engine类中。我们ContentManager将扩展XNA的ContentManager，能让我们选择是否使用content缓存（缓存能存储加载的对象，这样我们可以无需多次加载同一内容），并让我们可以卸载特定的内容而不是卸载所有的内容。以下是代码：
using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework.Content;
namespace Innovation
{
public class IEContentManager : ContentManager
{
// Do nothing in the constructor except inherit from ContentManager
public IEContentManager(IServiceProvider serviceProvider) : base(serviceProvider)
{
}
// Whether or not we should keep objects that have been loaded. This
// way we can avoid loading assets multiple times. However, this may
// lead to problems with multiple objects changing loaded data, such
// as effects on a model
public bool PreserveAssets = true;
// Keep a list of disposable assets and loaded assets
List disposable = new List();
Dictionary loaded = new Dictionary();
// Override loading of assets so we can use our own functionality
public override T Load(string assetName) {
// Create a new instance of the requested asset
T r = this.ReadAsset(assetName, RecordIDisposable);
// If we are holding on to loaded assets, add it to the list of
// loaded assets
if (PreserveAssets && !loaded.ContainsKey(assetName)) l
oaded.Add(assetName, r);
// Return the loaded asset
return r;
}
// Internal method to record disposable assets
void RecordIDisposable(IDisposable asset) {
// If we are monitoring loaded assets, add it to the list of
// disposable assets
if (PreserveAssets)
disposable.Add(asset);
}
// Unload all content
public override void Unload()
{
// Dispose all disposable assets
foreach (IDisposable disp in disposable)
disp.Dispose();
// Clear all loaded assets loaded.Clear();
disposable.Clear();
}
// Unload a specific piece of content
public void Unload(string assetName)
{
// If the asset has been loaded
if (loaded.ContainsKey(assetName))
{
// If it is disposable, dispose it and take it off the
// list of disposable content
if (loaded[assetName] is IDisposable && disposable.Contains((IDisposable)loaded[assetName]))
{
IDisposable obj = disposable[ disposable.IndexOf((IDisposable)loaded[assetName])];
obj.Dispose();
disposable.Remove(obj); }
// Take it off the list of loaded content
loaded.Remove(assetName);
}
}
}
}
现在，我们需要添加一个content manager实例到Engine类中。在其他成员声明附近添加以下代码：
// The engine's content manager
public static IEContentManager Content;
现在，将这个Content添加到SetupEngine（）最后并初始化：
// Setup the content manager using the service container
Engine.Content = new IEContentManager(Services);
现在我们要做的是添加一些GameScreens到Engine类。第一个GameScreen被称为BackgroundScreen，并重写了BlocksDraw，BlocksUpdate和BlocksInput。这样，我们可以拥有一些在后台运行的组件，这些组件需要更新或接受输入，如Input类。我们还将创建一个叫做DefaultScreen的GameScreen，并将它设置到BackgroundScreen。组件将加入到这个screen中。我们可以在运行时改变DefaultScreen，这样新的组件将建立在代替的screen上。如果现在的DefaultScreen被禁用，这将返回到BackgroundScreen。所以，加入以下代码到Engine类：
// GameScreen provided by the engine.
public static GameScreen BackgroundScreen;
// The GameScreen to set to new GameScreens when a screen is not specified
public static GameScreen DefaultScreen;
并添加以下代码到SetupEngine（）中：
// Setup the background screen
BackgroundScreen = new GameScreen("Engine.BackgroundScreen");
BackgroundScreen.OverrideUpdateBlocked = true;
BackgroundScreen.OverrideDrawBlocked = true;
BackgroundScreen.OverrideInputBlocked = true;
// Set the default screen to the background screen so new screens will
// use it automatically unless told otherwise
DefaultScreen = BackgroundScreen;
最后我们需要做的是创建GameScreenCollection类。这个类跟踪GameScreens。它继承自KeyedCollection，因此它可以根据GameScreen的名称返回一个GameScreen，例如： “Engine.GameScreens [”GameScreenName“]”。这样做比使用列表好，因为使用列表的话我们必须跟踪screen的IDs。还有一些逻辑是处理重置Engine.DefaultScreen（如果DefaultScreen被移除的时候）。代码如下：
using System.Collections.ObjectModel;
namespace Innovation
{
public class GameScreenCollection : KeyedCollection
{ // Allow us to get a screen by name like so:
// Engine.GameScreens["ScreenName"]
protected override string GetKeyForItem(GameScreen item)
{ return item.Name; }
protected override void RemoveItem(int index)
{
// Get the screen to be removed
GameScreen screen = Items[index];
// If this screen is the current default screen, set the
// default to the background screen
if (
Engine.DefaultScreen == screen)
Engine.DefaultScreen = Engine.BackgroundScreen;
base.RemoveItem(index);
}
}
}
好了，就这么多了！不要失望，现在我们已经完成了游戏引擎的框架！在接下来的教程中，我们将真正开始一些游戏组件编写！