using System;
using System.Collections.Generic;
using System.Reflection;
using System.Linq;
using Encompass.Exceptions;
using MoonTools.Core.Graph;
using MoonTools.Core.Graph.Extensions;
namespace Encompass
{
///
/// WorldBuilder is used to construct a World from Engines, Renderers, and an initial state of Entities, Components, and Messages.
///
///
/// WorldBuilder enforces certain rules about Engine structure. It is forbidden to have messages create cycles between Engines,
/// and no Component may be written by more than one Engine.
/// The WorldBuilder uses Engines and their Message read/emit information to determine a valid ordering of the Engines, which is given to the World.
///
public class WorldBuilder
{
private readonly int entityCapacity;
private readonly List engines = new List();
private readonly DirectedGraph engineGraph = GraphBuilder.DirectedGraph();
private readonly ComponentStore startingExistingComponentStore;
private readonly ComponentStore startingUpToDateComponentStore;
private readonly ComponentManager componentManager;
private readonly EntityManager entityManager;
private readonly MessageManager messageManager;
private readonly TimeManager timeManager;
private readonly DrawLayerManager drawLayerManager;
private readonly RenderManager renderManager;
private readonly TrackingManager trackingManager;
private readonly Dictionary> typeToReaders = new Dictionary>();
private readonly HashSet senders = new HashSet();
private readonly HashSet componentTypesToPreload = new HashSet();
private readonly HashSet messageTypes = new HashSet();
private readonly Dictionary typeToIndex = new Dictionary();
public WorldBuilder(int entityCapacity = 32768)
{
this.entityCapacity = entityCapacity;
drawLayerManager = new DrawLayerManager(typeToIndex);
timeManager = new TimeManager();
trackingManager = new TrackingManager();
componentManager = new ComponentManager(drawLayerManager, typeToIndex);
messageManager = new MessageManager(timeManager);
entityManager = new EntityManager(componentManager, entityCapacity);
renderManager = new RenderManager(entityManager, drawLayerManager);
startingExistingComponentStore = new ComponentStore(typeToIndex);
startingUpToDateComponentStore = new ComponentStore(typeToIndex);
}
///
/// Creates and returns a new empty Entity.
///
public Entity CreateEntity()
{
return entityManager.CreateEntity();
}
///
/// Specifies that the given Message should be sent immediately on the first World Update.
///
public void SendMessage(TMessage message) where TMessage : struct, IMessage
{
messageManager.AddMessage(message);
}
///
/// Specifies that the given Message should be sent after the specified number of seconds after the first World Update.
///
public void SendMessage(TMessage message, double time) where TMessage : struct, IMessage
{
messageManager.AddMessage(message, time);
}
///
/// Sets Component data for the specified Component Type on the specified Entity.
///
public void SetComponent(Entity entity, TComponent component) where TComponent : struct, IComponent
{
RegisterComponentType();
startingExistingComponentStore.Set(entity.ID, component);
startingUpToDateComponentStore.Set(entity.ID, component);
if (component is IDrawableComponent drawableComponent)
{
componentManager.RegisterDrawableComponent(entity.ID, component, drawableComponent.Layer);
drawLayerManager.RegisterOrderedDrawable();
}
}
internal void RegisterComponentType() where TComponent : struct, IComponent
{
if (!typeToIndex.ContainsKey(typeof(TComponent)))
{
typeToIndex.Add(typeof(TComponent), typeToIndex.Count);
componentTypesToPreload.Add(typeof(TComponent));
componentManager.RegisterComponentType();
startingExistingComponentStore.RegisterComponentType();
startingUpToDateComponentStore.RegisterComponentType();
}
}
internal void RegisterMessageTypes(IEnumerable types)
{
messageTypes.UnionWith(types);
}
///
/// Adds the specified Engine to the World.
///
/// An instance of an Engine.
public Engine AddEngine(TEngine engine) where TEngine : Engine
{
engine.AssignEntityManager(entityManager);
engine.AssignComponentManager(componentManager);
engine.AssignMessageManager(messageManager);
engine.AssignTimeManager(timeManager);
engine.AssignTrackingManager(trackingManager);
engines.Add(engine);
engineGraph.AddNode(engine);
var messageReceiveTypes = engine.receiveTypes;
var messageSendTypes = engine.sendTypes;
RegisterMessageTypes(engine.receiveTypes.Union(engine.sendTypes));
foreach (var writeImmediateType in engine.writeImmediateTypes.Intersect(engine.readImmediateTypes))
{
throw new EngineSelfCycleException("Engine {0} both writes and reads immediate Component {1}", engine.GetType().Name, writeImmediateType.Name);
}
foreach (var messageType in messageReceiveTypes.Intersect(messageSendTypes))
{
throw new EngineSelfCycleException("Engine {0} both receives and sends Message {1}", engine.GetType().Name, messageType.Name);
}
if (messageSendTypes.Count > 0 || engine.writeImmediateTypes.Count > 0)
{
senders.Add(engine);
}
foreach (var componentType in engine.queryWithTypes.Union(engine.queryWithoutTypes))
{
trackingManager.RegisterComponentTypeToEngine(componentType, engine);
if (engine.readImmediateTypes.Contains(componentType))
{
trackingManager.RegisterImmediateComponentTypeToEngine(componentType, engine);
}
}
foreach (var receiveType in engine.receiveTypes.Union(engine.readImmediateTypes))
{
if (!typeToReaders.ContainsKey(receiveType))
{
typeToReaders.Add(receiveType, new HashSet());
}
typeToReaders[receiveType].Add(engine);
}
return engine;
}
///
/// Registers a draw layer. This must be done before any Renderers are registered.
///
/// The draw layer to register.
public void RegisterDrawLayer(int layer)
{
drawLayerManager.RegisterDrawLayer(layer);
}
///
/// Adds the specified OrderedRenderer to the World.
///
public OrderedRenderer AddOrderedRenderer(OrderedRenderer renderer) where TComponent : struct, IComponent, IDrawableComponent
{
RegisterComponentType();
renderer.AssignEntityManager(entityManager);
renderer.AssignComponentManager(componentManager);
renderManager.RegisterOrderedRenderer(renderer.InternalRender);
return renderer;
}
///
/// Adds the specified GeneralRenderer to the World at the specified layer.
/// Higher layer numbers draw on top of lower layer numbers.
///
/// An instance of a GeneralRenderer.
/// The layer at which the GeneralRenderer should render. Higher numbers draw over lower numbers.
public TRenderer AddGeneralRenderer(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.Union(senderEngine.writeImmediateTypes))
{
if (typeToReaders.ContainsKey(messageType))
{
foreach (var readerEngine in typeToReaders[messageType])
{
if (senderEngine != readerEngine)
{
if (!engineGraph.Exists(senderEngine, readerEngine))
{
engineGraph.AddEdge(senderEngine, readerEngine);
}
}
}
}
}
}
}
///
/// Builds the World out of the state specified on the WorldBuilder.
/// Validates and constructs an ordering of the given Engines.
///
/// An instance of World.
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 writtenComponentTypesWithoutPriority = new HashSet();
var writtenComponentTypesWithPriority = new HashSet();
var duplicateWritesWithoutPriority = new List();
var duplicateWritesWithSamePriority = new List();
var writePriorities = new Dictionary>();
var writeMessageToEngines = new Dictionary>();
foreach (var engine in engines)
{
if (engine.GetType().GetCustomAttribute() != null)
{
engine.usesTimeDilation = false;
}
var defaultWritePriorityAttribute = engine.GetType().GetCustomAttribute(false);
foreach (var writeType in engine.writeTypes)
{
int? priority = null;
if (engine.writePriorities.ContainsKey(writeType))
{
priority = engine.writePriorities[writeType];
}
else if (defaultWritePriorityAttribute != null)
{
priority = defaultWritePriorityAttribute.writePriority;
}
if (priority.HasValue)
{
writtenComponentTypesWithPriority.Add(writeType);
if (!writePriorities.ContainsKey(writeType))
{
writePriorities[writeType] = new HashSet();
}
if (writePriorities[writeType].Contains(priority.Value))
{
duplicateWritesWithSamePriority.Add(writeType);
}
else if (writtenComponentTypesWithoutPriority.Contains(writeType))
{
duplicateWritesWithoutPriority.Add(writeType);
}
else
{
writePriorities[writeType].Add(priority.Value);
}
}
else
{
if (writtenComponentTypesWithoutPriority.Contains(writeType) || writtenComponentTypesWithPriority.Contains(writeType))
{
duplicateWritesWithoutPriority.Add(writeType);
}
else
{
writtenComponentTypesWithoutPriority.Add(writeType);
}
}
if (!writeMessageToEngines.ContainsKey(writeType))
{
writeMessageToEngines[writeType] = new List();
}
writeMessageToEngines[writeType].Add(engine);
}
}
if (duplicateWritesWithoutPriority.Count > 0)
{
var errorString = "Multiple Engines write the same Component without declaring priority: ";
foreach (var componentType in duplicateWritesWithoutPriority)
{
errorString += "\n" +
componentType.Name + " written by: " +
string.Join(", ", writeMessageToEngines[componentType].Select((engine) => engine.GetType().Name));
}
errorString += "\nTo resolve the conflict, add priority arguments to the Writes declarations or use a DefaultWritePriority attribute.";
throw new EngineWriteConflictException(errorString);
}
if (duplicateWritesWithSamePriority.Count > 0)
{
var errorString = "Multiple Engines write the same Component with the same priority: ";
foreach (var componentType in duplicateWritesWithSamePriority)
{
errorString += "\n" +
componentType.Name + " written by: " +
string.Join(", ", writeMessageToEngines[componentType].Select(engine => engine.GetType().Name));
}
errorString += "\nTo resolve the conflict, add priority arguments to the Writes declarations or use a DefaultWritePriority attribute.";
throw new EngineWriteConflictException(errorString);
}
// doing reflection to grab all component types, because not all writes need to be declared
foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
{
foreach (var componentType in assembly.GetTypes())
{
if (typeof(IComponent).IsAssignableFrom(componentType) && componentType.IsValueType && !componentType.IsEnum && !componentType.IsPrimitive)
{
var method = typeof(WorldBuilder).GetMethod("RegisterComponentType", BindingFlags.NonPublic | BindingFlags.Instance);
var generic = method.MakeGenericMethod(componentType);
generic.Invoke(this, null);
}
}
}
PreloadJIT(componentTypesToPreload, messageTypes);
var engineOrder = new List();
foreach (var engine in engineGraph.TopologicalSort())
{
engineOrder.Add(engine);
engine.BuildEntityQuery();
}
var world = new World(
engineOrder,
entityManager,
componentManager,
trackingManager,
messageManager,
timeManager,
renderManager
);
componentManager.SetExistingComponentStore(startingExistingComponentStore);
componentManager.SetUpToDateComponentStore(startingUpToDateComponentStore);
trackingManager.InitializeTracking(entityManager.EntityIDs);
return world;
}
///
/// This is necessary because Encompass heavily uses generic methods with value types,
/// so the first time any code path runs the JIT gets smashed. This method warms up the runtime.
/// It does so by grabbing all component and message types known to the WorldBuilder and
/// executing every possible generic method that could be executed with those types.
///
private void PreloadJIT(IEnumerable componentTypes, IEnumerable messageTypes)
{
var dummyTimeManager = new TimeManager();
var dummyMessageManager = new MessageManager(dummyTimeManager);
var dummyDrawLayerManager = new DrawLayerManager(typeToIndex);
var dummyTrackingManager = new TrackingManager();
var dummyComponentManager = new ComponentManager(dummyDrawLayerManager, typeToIndex);
var dummyEntityManager = new EntityManager(dummyComponentManager, entityCapacity);
var dummyRenderManager = new RenderManager(dummyEntityManager, dummyDrawLayerManager);
var prepEngineOrder = new List();
var uberEngine = new UberEngine(componentTypes, messageTypes);
uberEngine.AssignEntityManager(dummyEntityManager);
uberEngine.AssignComponentManager(dummyComponentManager);
uberEngine.AssignMessageManager(dummyMessageManager);
uberEngine.AssignTimeManager(dummyTimeManager);
uberEngine.AssignTrackingManager(dummyTrackingManager);
var uberRenderer = new UberRenderer(componentTypes);
uberRenderer.AssignComponentManager(dummyComponentManager);
uberRenderer.AssignEntityManager(dummyEntityManager);
foreach (var type in componentTypes)
{
var componentManagerRegisterMethod = typeof(ComponentManager).GetMethod("RegisterComponentType");
var componentManagerRegisterGenericMethod = componentManagerRegisterMethod.MakeGenericMethod(type);
componentManagerRegisterGenericMethod.Invoke(dummyComponentManager, null);
if (type.GetInterface("IDrawableComponent") != null)
{
var drawLayerManagerRegisterMethod = typeof(DrawLayerManager).GetMethod("RegisterOrderedDrawable");
var drawLayerManagerRegisterGenericMethod = drawLayerManagerRegisterMethod.MakeGenericMethod(type);
drawLayerManagerRegisterGenericMethod.Invoke(dummyDrawLayerManager, null);
}
}
prepEngineOrder.Add(uberEngine);
var dummyWorld = new World(
prepEngineOrder,
dummyEntityManager,
dummyComponentManager,
dummyTrackingManager,
dummyMessageManager,
dummyTimeManager,
dummyRenderManager
);
uberEngine.Write();
dummyComponentManager.WriteComponents();
dummyWorld.Update(1);
uberEngine.Write();
dummyComponentManager.WriteComponents();
uberRenderer.SetEntity(uberEngine.Entity);
uberRenderer.Render();
}
}
}