encompass-cs/encompass-cs/WorldBuilder.cs

263 lines
9.9 KiB
C#

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Linq;
using Encompass.Exceptions;
using Encompass.Engines;
namespace Encompass
{
public class WorldBuilder
{
private readonly List<Engine> engines = new List<Engine>();
private readonly DirectedGraph<Engine> engineGraph = new DirectedGraph<Engine>();
private readonly ComponentManager componentManager;
private readonly EntityManager entityManager;
private readonly MessageManager messageManager;
private readonly ComponentMessageManager componentMessageManager;
private readonly DrawLayerManager drawLayerManager;
private readonly RenderManager renderManager;
private readonly Dictionary<Type, HashSet<Engine>> typeToReaders = new Dictionary<Type, HashSet<Engine>>();
private readonly HashSet<Engine> senders = new HashSet<Engine>();
private readonly HashSet<Type> registeredComponentTypes = new HashSet<Type>();
public WorldBuilder()
{
drawLayerManager = new DrawLayerManager();
componentManager = new ComponentManager(drawLayerManager);
messageManager = new MessageManager();
componentMessageManager = new ComponentMessageManager();
entityManager = new EntityManager(componentManager, componentMessageManager);
renderManager = new RenderManager(componentManager, drawLayerManager);
}
public Entity CreateEntity()
{
return entityManager.CreateEntity();
}
public void SendMessage<TMessage>(TMessage message) where TMessage : struct, IMessage
{
messageManager.AddMessage(message);
}
public Guid AddComponent<TComponent>(Entity entity, TComponent component) where TComponent : struct, IComponent
{
return componentManager.MarkComponentForAdd(entity, component);
}
public Guid AddDrawComponent<TComponent>(Entity entity, TComponent component, int layer = 0) where TComponent : struct, IComponent
{
return componentManager.MarkDrawComponentForAdd(entity, component, layer);
}
internal void RegisterComponent(Type componentType)
{
registeredComponentTypes.Add(componentType);
AddEngine((Engine)Activator.CreateInstance(typeof(ComponentMessageEmitter<>).MakeGenericType(componentType)));
}
internal void RegisterNewComponentUpdater(Type componentType)
{
AddEngine((Engine)Activator.CreateInstance(typeof(ComponentUpdater<>).MakeGenericType(componentType)));
}
public Engine AddEngine<TEngine>(TEngine engine) where TEngine : Engine
{
engine.AssignEntityManager(entityManager);
engine.AssignComponentManager(componentManager);
engine.AssignMessageManager(messageManager);
engine.AssignComponentMessageManager(componentMessageManager);
engines.Add(engine);
engineGraph.AddVertex(engine);
var messageReceiveTypes = engine.receiveTypes;
var messageSendTypes = engine.sendTypes;
foreach (var messageType in messageReceiveTypes.Union(messageSendTypes))
{
messageManager.RegisterMessageType(messageType);
}
foreach (var messageType in messageReceiveTypes.Intersect(messageSendTypes))
{
if ((messageType.IsGenericType && messageType.GetGenericTypeDefinition() == typeof(PendingComponentMessage<>)))
{
var componentType = messageType.GetGenericArguments().Single();
throw new EngineSelfCycleException("Engine {0} both activates and reads pending Component {1}", engine.GetType().Name, componentType.Name);
}
throw new EngineSelfCycleException("Engine {0} both receives and sends Message {1}", engine.GetType().Name, messageType.Name);
}
if (messageSendTypes.Any())
{
senders.Add(engine);
}
foreach (var receiveType in engine.receiveTypes)
{
if (receiveType.IsGenericType)
{
var genericTypeDefinition = receiveType.GetGenericTypeDefinition();
if (genericTypeDefinition == typeof(ComponentMessage<>) || genericTypeDefinition == typeof(PendingComponentMessage<>))
{
var componentType = receiveType.GetGenericArguments().Single();
if (!registeredComponentTypes.Contains(componentType))
{
RegisterComponent(componentType);
}
}
}
if (!typeToReaders.ContainsKey(receiveType))
{
typeToReaders.Add(receiveType, new HashSet<Engine>());
}
typeToReaders[receiveType].Add(engine);
}
foreach (var sendType in engine.sendTypes)
{
if (sendType.IsGenericType)
{
var genericTypeDefinition = sendType.GetGenericTypeDefinition();
if (genericTypeDefinition == typeof(ComponentUpdateMessage<>))
{
var componentType = sendType.GetGenericArguments().Single();
RegisterNewComponentUpdater(componentType);
}
}
}
return engine;
}
public OrderedRenderer<TComponent> AddOrderedRenderer<TComponent>(OrderedRenderer<TComponent> renderer) where TComponent : struct, IComponent
{
renderer.AssignEntityManager(entityManager);
renderer.AssignComponentManager(componentManager);
renderManager.RegisterOrderedRenderer<TComponent>(renderer.InternalRender);
return renderer;
}
public TRenderer AddGeneralRenderer<TRenderer>(TRenderer renderer, int layer) where TRenderer : GeneralRenderer
{
renderer.AssignEntityManager(entityManager);
renderer.AssignComponentManager(componentManager);
renderManager.RegisterGeneralRendererWithLayer(renderer, layer);
return renderer;
}
private void BuildEngineGraph()
{
foreach (var senderEngine in senders)
{
foreach (var messageType in senderEngine.sendTypes.Where((type) => type.GetInterfaces().Contains(typeof(IMessage))))
{
if (typeToReaders.ContainsKey(messageType))
{
foreach (var readerEngine in typeToReaders[messageType])
{
if (senderEngine != readerEngine)
{
engineGraph.AddEdge(senderEngine, readerEngine);
}
}
}
}
}
}
public World Build()
{
BuildEngineGraph();
if (engineGraph.Cyclic())
{
var cycles = engineGraph.SimpleCycles();
var errorString = "Cycle(s) found in Engines: ";
foreach (var cycle in cycles)
{
var reversed = cycle.Reverse();
errorString += "\n" +
string.Join(" -> ", reversed.Select((engine) => engine.GetType().Name)) +
" -> " +
reversed.First().GetType().Name;
}
throw new EngineCycleException(errorString);
}
var mutatedComponentTypes = new HashSet<Type>();
var duplicateMutations = new List<Type>();
var updateMessageToEngines = new Dictionary<Type, List<Engine>>();
foreach (var engine in engines)
{
var updateTypes = engine.sendTypes.Where((type) => type.IsGenericType && type.GetGenericTypeDefinition() == typeof(ComponentUpdateMessage<>));
foreach (var updateType in updateTypes)
{
if (mutatedComponentTypes.Contains(updateType))
{
duplicateMutations.Add(updateType);
}
else
{
mutatedComponentTypes.Add(updateType);
}
if (!updateMessageToEngines.ContainsKey(updateType))
{
updateMessageToEngines[updateType] = new List<Engine>();
}
updateMessageToEngines[updateType].Add(engine);
}
}
if (duplicateMutations.Count > 0)
{
var errorString = "Multiple Engines update the same Component: ";
foreach (var componentType in duplicateMutations)
{
errorString += "\n" +
componentType.Name + " updated by: " +
string.Join(", ", updateMessageToEngines[componentType].Select((engine) => engine.GetType().Name));
}
throw new EngineUpdateConflictException(errorString);
}
var engineOrder = new List<Engine>();
foreach (var engine in engineGraph.TopologicalSort())
{
engineOrder.Add(engine);
}
var world = new World(
engineOrder,
entityManager,
componentManager,
messageManager,
componentMessageManager,
renderManager
);
componentManager.PerformComponentUpdates();
componentManager.RemoveMarkedComponents();
componentManager.AddMarkedComponents();
return world;
}
}
}