/// <summary>Called when behaviour instance is being loaded</summary>
public void Awake()
{
// Set the singleton instance
if (GameBehaviour.Instance != null)
{
throw new InvalidOperationException("Only one instance of GameBehaviour is allowed per scene");
}
GameBehaviour.Instance = this;
// Resolve the asset loaders
ResourceManager.RegisterResourceLoaders(GlobalContainer.ResolveAll <IResourceLoader>());
// Register the resource library singleton
var resources = ResourceLibrary.FromString(this.ResourceLibraryXml.text);
new DependencyContainer().RegisterSingleton <IResourceLibrary>(resources);
// Create the IGame instance
var gameDefinition = resources.GetSerializedResource <GameDefinition>(this.GameDefinitionId);
this.game = (UnityGame)GlobalContainer.Resolve <IGameFactory>().Create(gameDefinition);
//// Log.Trace("Loaded game '{0}' with {1} levels:\n{2}", this.game.Title, this.game.Levels.Length, string.Join("\n", this.game.Levels.Select(l => "{0} ({1})".FormatInvariant(l.Title, l.Id)).ToArray()));
//// TODO: Drive level loading from a menu system
// Load the first level
var firstLevel = this.game.Levels.First().Id;
Log.Trace("Loading level '{0}'...", firstLevel);
this.game.LoadLevel(firstLevel);
}
/// <summary>Creates an entity controller instance</summary>
/// <param name="controllerId">Controller identifier</param>
/// <param name="settings">Controller configuration</param>
/// <param name="target">Controller target</param>
/// <returns>The created IGame instance</returns>
public virtual IController Create(string controllerId, IConfig settings, IControllerTarget target)
{
#if DEBUG
if (!this.constructors.ContainsKey(controllerId))
{
throw new ArgumentOutOfRangeException(
"controllerConfig", "No controller found with id '{0}'.".FormatInvariant(controllerId));
}
#endif
var ctor = this.constructors[controllerId];
//// Log.Trace("Creating controller '{0}' ({1}) with target '{2}'\nSettings: {3}", controllerId, ctor.DeclaringType.FullName, target.Id, settings);
var defaultParameters = new Dictionary <Type, object>
{
{ typeof(IResourceLibrary), this.resources },
{ typeof(TControllerTarget), target },
{ typeof(IConfig), settings },
};
var parameters = ctor.GetParameters().Select(p => p.ParameterType)
.Select(t =>
defaultParameters.ContainsKey(t) ? defaultParameters[t] :
t.IsArray ? GlobalContainer.ResolveAll(t) :
GlobalContainer.Resolve(t))
.ToArray();
var controller = (IController)ctor.Invoke(parameters);
this.controllerManager.AddController(controller);
return(controller);
}
public void ResolveAllUsingGlobalContainer()
{
new DependencyContainer()
.RegisterType <ITestTypeA, TestTypeA1>("One");
new DependencyContainer()
.RegisterType <ITestTypeA, TestTypeA2>("Two");
var instances = GlobalContainer.ResolveAll <ITestTypeA>();
Assert.IsNotNull(instances);
Assert.AreEqual(2, instances.Count());
Assert.IsTrue(new[] { typeof(TestTypeA1), typeof(TestTypeA2) }
.All(t => instances.Any(i => i.GetType() == t)));
}
public void ResolveRegisteredLoaders()
{
var loaders = GlobalContainer.ResolveAll <IResourceLoader>();
Assert.AreEqual(2, loaders.Count());
var textAssetLoader = GlobalContainer.Resolve <IResourceLoader>("Unity TextAsset Loader");
Assert.IsInstanceOf <TextAssetResourceLoader>(textAssetLoader);
var prefabLoader = GlobalContainer.Resolve <IResourceLoader>("Unity Prefab Loader");
Assert.IsInstanceOf <PrefabAssetResourceLoader>(prefabLoader);
}
public void ResolveRegisteredLoggers()
{
var loggers = GlobalContainer.ResolveAll <ILogger>();
Assert.AreEqual(1, loggers.Count());
var loggerA = loggers.Single();
Assert.IsInstanceOf <Core.GenericAsyncLogger <Core.Unity.DebugConsoleLogger> >(loggerA);
var loggerB = GlobalContainer.Resolve <ILogger>();
Assert.AreSame(loggerA, loggerB);
var loggerC = GlobalContainer.Resolve <ILogger>("Unity Async Debug Logger");
Assert.AreSame(loggerB, loggerC);
}