encompass-cs/encompass-cs/Engine.cs

809 lines
34 KiB
C#

using System;
using System.Reflection;
using System.Collections.Generic;
using System.Linq;
using Encompass.Exceptions;
namespace Encompass
{
/// <summary>
/// Engines are the Encompass notion of an ECS System.
/// They are responsible for reading the World state, reading messages, emitting messages, and creating or mutating Entities and Components.
/// Engines run once per World Update.
/// </summary>
public abstract class Engine : IEquatable<Engine>
{
internal Guid _id;
internal readonly HashSet<Type> ReadTypes = new HashSet<Type>();
internal readonly HashSet<Type> ReadImmediateTypes = new HashSet<Type>();
internal readonly HashSet<Type> SendTypes = new HashSet<Type>();
internal readonly HashSet<Type> ReceiveTypes = new HashSet<Type>();
internal readonly HashSet<Type> WriteTypes = new HashSet<Type>();
internal readonly HashSet<Type> WriteImmediateTypes = new HashSet<Type>();
internal readonly HashSet<Type> QueryWithTypes = new HashSet<Type>();
internal readonly HashSet<Type> QueryWithoutTypes = new HashSet<Type>();
internal readonly HashSet<Type> AddTypes = new HashSet<Type>();
internal readonly Dictionary<Type, int> WritePriorities = new Dictionary<Type, int>();
internal readonly int DefaultWritePriority = 0;
/// <summary>
/// If false, the Engine will ignore time dilation.
/// </summary>
internal bool _usesTimeDilation = true;
public bool TimeDilationActive { get => _usesTimeDilation && _timeManager.TimeDilationActive; }
private EntityManager _entityManager;
private MessageManager _messageManager;
private ComponentManager _componentManager;
private TimeManager _timeManager;
private TrackingManager _trackingManager;
private EntitySetQuery _entityQuery;
private readonly HashSet<int> _trackedEntities = new HashSet<int>();
protected IEnumerable<Entity> TrackedEntities
{
get
{
foreach (var entityID in _trackedEntities)
{
yield return _entityManager.GetEntity(entityID);
}
}
}
private readonly HashSet<int> _newlyCreatedEntities = new HashSet<int>();
protected Engine()
{
_id = Guid.NewGuid();
var addsAttribute = GetType().GetCustomAttribute<Adds>(false);
if (addsAttribute != null)
{
AddTypes = addsAttribute.addTypes;
}
var sendsAttribute = GetType().GetCustomAttribute<Sends>(false);
if (sendsAttribute != null)
{
SendTypes = sendsAttribute.SendTypes;
}
var activatesAttribute = GetType().GetCustomAttribute<WritesImmediate>(false);
if (activatesAttribute != null)
{
WriteImmediateTypes = activatesAttribute.WriteImmediateTypes;
}
var defaultWritePriorityAttribute = GetType().GetCustomAttribute<DefaultWritePriority>(false);
if (defaultWritePriorityAttribute != null)
{
DefaultWritePriority = defaultWritePriorityAttribute.WritePriority;
}
foreach (var writesAttribute in GetType().GetCustomAttributes<Writes>(false))
{
WriteTypes.UnionWith(writesAttribute.WriteTypes);
WritePriorities = new Dictionary<Type, int>[2] { WritePriorities, writesAttribute.Priorities }.SelectMany(dict => dict).ToDictionary(pair => pair.Key, pair => pair.Value);
}
var receivesAttribute = GetType().GetCustomAttribute<Receives>(false);
if (receivesAttribute != null)
{
ReceiveTypes = receivesAttribute.ReceiveTypes;
}
var readsAttribute = GetType().GetCustomAttribute<Reads>(false);
if (readsAttribute != null)
{
ReadTypes = readsAttribute.ReadTypes;
}
var readsImmediateAttribute = GetType().GetCustomAttribute<ReadsImmediate>(false);
if (readsImmediateAttribute != null)
{
ReadImmediateTypes = readsImmediateAttribute.ReadImmediateTypes;
}
var queryWithAttribute = GetType().GetCustomAttribute<QueryWith>(false);
if (queryWithAttribute != null)
{
QueryWithTypes = queryWithAttribute.QueryWithTypes;
}
foreach (var queryType in QueryWithTypes)
{
ReadTypes.Add(queryType);
}
var queryWithoutAttribute = GetType().GetCustomAttribute<QueryWithout>(false);
if (queryWithoutAttribute != null)
{
QueryWithoutTypes = queryWithoutAttribute.QueryWithoutTypes;
}
foreach (var queryType in QueryWithoutTypes)
{
ReadTypes.Add(queryType);
}
}
public override bool Equals(object obj)
{
if (obj is Engine engine)
{
return Equals(engine);
}
return false;
}
public bool Equals(Engine other)
{
return other._id == _id;
}
public override int GetHashCode()
{
return HashCode.Combine(_id);
}
internal void AssignEntityManager(EntityManager entityManager)
{
_entityManager = entityManager;
}
internal void AssignComponentManager(ComponentManager componentManager)
{
_componentManager = componentManager;
}
internal void AssignMessageManager(MessageManager messageManager)
{
_messageManager = messageManager;
}
internal void AssignTimeManager(TimeManager timeManager)
{
_timeManager = timeManager;
}
internal void AssignTrackingManager(TrackingManager trackingManager)
{
_trackingManager = trackingManager;
}
internal void CheckMessageRead<TMessage>() where TMessage : struct
{
if (!ReceiveTypes.Contains(typeof(TMessage)))
{
throw new IllegalReadException("Engine {0} tried to read undeclared Message {1}", this.GetType().Name, typeof(TMessage).Name);
}
}
private bool EntityCreatedThisFrame(int entityID)
{
return _newlyCreatedEntities.Contains(entityID);
}
internal void ClearNewlyCreatedEntities()
{
_newlyCreatedEntities.Clear();
}
/// <summary>
/// Runs once per World update with the calculated delta-time.
/// </summary>
/// <param name="dt">The time in seconds that has elapsed since the previous frame.</param>
public abstract void Update(double dt);
/// <summary>
/// Creates and returns a new empty Entity.
/// </summary>
protected Entity CreateEntity()
{
var entity = _entityManager.CreateEntity();
_newlyCreatedEntities.Add(entity.ID);
return entity;
}
/// <summary>
/// Returns true if an Entity with the specified ID exists.
/// </summary>
protected bool EntityExists(in Entity entity)
{
return _entityManager.EntityExists(entity.ID);
}
/// <summary>
/// Returns true if an Entity with the specified ID exists.
/// </summary>
protected bool EntityExists(int entityID)
{
return _entityManager.EntityExists(entityID);
}
/// <summary>
/// Returns all Entities containing the specified Component type.
/// </summary>
protected ReadOnlySpan<Entity> ReadEntities<TComponent>() where TComponent : struct
{
var immediateRead = ReadImmediateTypes.Contains(typeof(TComponent));
var existingRead = ReadTypes.Contains(typeof(TComponent));
if (existingRead && immediateRead)
{
return _componentManager.GetExistingAndImmediateEntities<TComponent>();
}
else if (existingRead)
{
return _componentManager.GetExistingEntities<TComponent>();
}
else if (immediateRead)
{
return _componentManager.GetImmediateEntities<TComponent>();
}
else
{
throw new IllegalReadException("Engine {0} tried to read undeclared Component {1}", GetType().Name, typeof(TComponent).Name);
}
}
/// <summary>
/// Returns an Entity containing the specified Component type.
/// </summary>
protected ref readonly Entity ReadEntity<TComponent>() where TComponent : struct
{
var immediateRead = ReadImmediateTypes.Contains(typeof(TComponent));
var existingRead = ReadTypes.Contains(typeof(TComponent));
if (existingRead && immediateRead)
{
return ref _componentManager.ExistingOrImmediateSingularEntity<TComponent>();
}
else if (existingRead)
{
return ref _componentManager.ExistingSingularEntity<TComponent>();
}
else if (immediateRead)
{
return ref _componentManager.ImmediateSingularEntity<TComponent>();
}
else
{
throw new IllegalReadException("Engine {0} tried to read undeclared Component {1}", GetType().Name, typeof(TComponent).Name);
}
}
/// <summary>
/// Returns all of the Components with the specified Component Type.
/// </summary>
protected ReadOnlySpan<TComponent> ReadComponents<TComponent>() where TComponent : struct
{
var immediateRead = ReadImmediateTypes.Contains(typeof(TComponent));
var existingRead = ReadTypes.Contains(typeof(TComponent));
if (existingRead && immediateRead)
{
return _componentManager.ReadExistingAndImmediateComponentsByType<TComponent>();
}
else if (existingRead)
{
return _componentManager.GetExistingComponents<TComponent>();
}
else if (immediateRead)
{
return _componentManager.ReadImmediateComponentsByType<TComponent>();
}
else
{
throw new IllegalReadException("Engine {0} tried to read undeclared Component {1}", GetType().Name, typeof(TComponent).Name);
}
}
/// <summary>
/// Returns a Component with the specified Component Type. If multiples exist, an arbitrary Component is returned.
/// </summary>
protected ref readonly TComponent ReadComponent<TComponent>() where TComponent : struct
{
var immediateRead = ReadImmediateTypes.Contains(typeof(TComponent));
var existingRead = ReadTypes.Contains(typeof(TComponent));
if (existingRead && immediateRead)
{
return ref _componentManager.ExistingOrImmediateSingular<TComponent>();
}
else if (existingRead)
{
return ref _componentManager.ExistingSingular<TComponent>();
}
else if (immediateRead)
{
return ref _componentManager.ImmediateSingular<TComponent>();
}
else
{
throw new IllegalReadException("Engine {0} tried to read undeclared Component {1}", GetType().Name, typeof(TComponent).Name);
}
}
/// <summary>
/// Returns true if any Component with the specified Component Type exists.
/// </summary>
protected bool SomeComponent<TComponent>() where TComponent : struct
{
var immediateRead = ReadImmediateTypes.Contains(typeof(TComponent));
var existingRead = ReadTypes.Contains(typeof(TComponent));
if (existingRead && immediateRead)
{
return _componentManager.SomeExistingOrImmediateComponent<TComponent>();
}
else if (existingRead)
{
return _componentManager.SomeExistingComponent<TComponent>();
}
else if (immediateRead)
{
return _componentManager.SomeImmediateComponent<TComponent>();
}
else
{
throw new IllegalReadException("Engine {0} tried to read undeclared Component {1}", GetType().Name, typeof(TComponent).Name);
}
}
private ref TComponent GetComponentHelper<TComponent>(int entityID) where TComponent : struct
{
var immediateRead = ReadImmediateTypes.Contains(typeof(TComponent));
var existingRead = ReadTypes.Contains(typeof(TComponent));
if (existingRead && immediateRead)
{
return ref _componentManager.ReadImmediateOrExistingComponentByEntityAndType<TComponent>(entityID);
}
else if (existingRead)
{
return ref _componentManager.ReadExistingComponentByEntityAndType<TComponent>(entityID);
}
else if (immediateRead)
{
return ref _componentManager.ReadImmediateComponentByEntityAndType<TComponent>(entityID);
}
else
{
throw new IllegalReadException("Engine {0} tried to read undeclared Component {1}", GetType().Name, typeof(TComponent).Name);
}
}
/// <summary>
/// Returns a Component with the specified Type that exists on the Entity.
/// </summary>
/// <exception cref="Encompass.Exceptions.NoComponentOfTypeOnEntityException">
/// Thrown when the Entity does not have a Component of the specified Type
/// </exception>
/// <exception cref="Encompass.Exceptions.IllegalReadException">
/// Thrown when the Engine does not declare that it reads the given Component Type.
/// </exception>
protected ref readonly TComponent GetComponent<TComponent>(in Entity entity) where TComponent : struct
{
return ref GetComponentHelper<TComponent>(entity.ID);
}
/// <summary>
/// Returns true if the Entity has a Component of the given Type.
/// </summary>
/// <exception cref="Encompass.Exceptions.IllegalReadException">
/// Thrown when the Engine does not declare that is Reads the given Component Type.
/// </exception>
protected bool HasComponent<TComponent>(in Entity entity) where TComponent : struct
{
var immediateRead = ReadImmediateTypes.Contains(typeof(TComponent));
var existingRead = ReadTypes.Contains(typeof(TComponent));
if (immediateRead && existingRead)
{
return _componentManager.HasExistingOrImmediateComponent<TComponent>(entity.ID);
}
else if (existingRead)
{
return _componentManager.HasExistingComponent<TComponent>(entity.ID);
}
else if (immediateRead)
{
return _componentManager.HasImmediateComponent<TComponent>(entity.ID);
}
else
{
throw new IllegalReadException("Engine {0} tried to read undeclared Component {1}", GetType().Name, typeof(TComponent).Name);
}
}
/// <summary>
/// Returns true if the Entity has a Component of the given Type.
/// </summary>
/// <exception cref="Encompass.Exceptions.IllegalReadException">
/// Thrown when the Engine does not declare that is Reads the given Component Type.
/// </exception>
protected bool HasComponent(in Entity entity, Type type)
{
var immediateRead = ReadImmediateTypes.Contains(type);
var existingRead = ReadTypes.Contains(type);
if (immediateRead && existingRead)
{
return _componentManager.HasExistingOrImmediateComponent(entity.ID, type);
}
else if (existingRead)
{
return _componentManager.HasExistingComponent(entity.ID, type);
}
else if (immediateRead)
{
return _componentManager.HasImmediateComponent(entity.ID, type);
}
else
{
throw new IllegalReadException("Engine {0} tried to read undeclared Component {1}", GetType().Name, type.Name);
}
}
/// <summary>
/// Sets Component data for the specified Component Type on the specified Entity. If Component data for this Type already existed on the Entity, the component data is overwritten.
/// </summary>
/// <exception cref="Encompass.Exceptions.IllegalWriteException">
/// Thrown when the Engine does not declare that it Writes the given Component Type.
/// </exception>
protected void SetComponent<TComponent>(in Entity entity, in TComponent component) where TComponent : struct
{
var priority = WritePriorities.ContainsKey(typeof(TComponent)) ? WritePriorities[typeof(TComponent)] : DefaultWritePriority;
if (!WriteTypes.Contains(typeof(TComponent)))
{
throw new IllegalWriteException("Engine {0} tried to update undeclared Component {1}", GetType().Name, typeof(TComponent).Name);
}
bool written;
if (WriteImmediateTypes.Contains(typeof(TComponent)))
{
written = _componentManager.AddImmediateComponent(entity.ID, component, priority);
if (written)
{
_trackingManager.ImmediateUpdateTracking(entity.ID, typeof(TComponent));
}
}
else
{
written = _componentManager.UpdateComponent(entity.ID, component, priority);
}
if (!_componentManager.HasExistingComponent<TComponent>(entity.ID))
{
_trackingManager.RegisterAddition(entity.ID, typeof(TComponent));
}
}
/// <summary>
/// An alternative to SetComponent that can be used for new Entities and does not require setting write priority.
/// </summary>
/// <exception cref="Encompass.Exceptions.IllegalWriteException">
/// Thrown when the Engine does not declare that it Writes the given Component Type.
/// </exception>
protected void AddComponent<TComponent>(in Entity entity, in TComponent component) where TComponent : struct
{
if (!AddTypes.Contains(typeof(TComponent)))
{
throw new IllegalWriteException("Engine {0} tried to add undeclared Component {1}", GetType().Name, typeof(TComponent).Name);
}
if (!EntityCreatedThisFrame(entity.ID))
{
throw new IllegalWriteException("AddComponent used on Entity that was not created in this context. Use SetComponent instead.");
}
if (WriteImmediateTypes.Contains(typeof(TComponent)))
{
_componentManager.AddImmediateComponent(entity.ID, component);
_trackingManager.ImmediateUpdateTracking(entity.ID, typeof(TComponent));
}
else
{
_componentManager.AddComponent(entity.ID, component);
}
_trackingManager.RegisterAddition(entity.ID, typeof(TComponent));
}
/// <summary>
/// Sends a Message.
/// </summary>
/// <exception cref="Encompass.Exceptions.IllegalSendException">
/// Thrown when the Engine does not declare that it Sends the Message Type.
/// </exception>
protected void SendMessage<TMessage>(in TMessage message) where TMessage : struct
{
if (!SendTypes.Contains(typeof(TMessage)))
{
throw new IllegalSendException("Engine {0} tried to send undeclared Message {1}", GetType().Name, typeof(TMessage).Name);
}
_messageManager.AddMessage(message);
}
/// <summary>
/// Sends a message after the specified number of seconds, respecting time dilation.
/// </summary>
/// <param name="time">The time in seconds that will elapse before the message is sent.</param>
protected void SendMessage<TMessage>(in TMessage message, double time) where TMessage : struct
{
_messageManager.AddMessage(message, time);
}
/// <summary>
/// Sends a message after the specified number of seconds, ignoring time dilation.
/// </summary>
/// <param name="time">The time in seconds that will elapse before the message is sent.</param>
protected void SendMessageIgnoringTimeDilation<TMessage>(in TMessage message, double time) where TMessage : struct
{
_messageManager.AddMessageIgnoringTimeDilation(message, time);
}
/// <summary>
/// Reads all messages of the specified Type.
/// </summary>
/// <exception cref="Encompass.Exceptions.IllegalReadException">
/// Thrown when the Engine does not declare that it Receives the specified Message Type.
/// </exception>
protected ReadOnlySpan<TMessage> ReadMessages<TMessage>() where TMessage : struct
{
CheckMessageRead<TMessage>();
return _messageManager.GetMessagesByType<TMessage>();
}
/// <summary>
/// Reads an arbitrary message of the specified Type.
/// </summary>
/// <exception cref="Encompass.Exceptions.IllegalReadException">
/// Thrown when the Engine does not declare that it Receives the specified Message Type.
/// </exception>
protected ref readonly TMessage ReadMessage<TMessage>() where TMessage : struct
{
CheckMessageRead<TMessage>();
return ref _messageManager.First<TMessage>();
}
/// <summary>
/// Returns true if a Message of the specified Type has been sent this frame.
/// </summary>
/// <exception cref="Encompass.Exceptions.IllegalReadException">
/// Thrown when the Engine does not declare that it Receives the specified Message Type.
/// </exception>
protected bool SomeMessage<TMessage>() where TMessage : struct
{
CheckMessageRead<TMessage>();
return _messageManager.Any<TMessage>();
}
/// <summary>
/// Destroys the specified Entity. This also removes all of the Components associated with the Entity.
/// Entity destruction takes place after all the Engines have been processed by World Update.
/// </summary>
protected void Destroy(in Entity entity)
{
_entityManager.MarkForDestroy(entity.ID);
}
/// <summary>
/// Destroys an arbitrary Entity containing a Component of the specified Type.
/// Entity destruction takes place after all the Engines have been processed by World Update.
/// </summary>
protected void DestroyWith<TComponent>() where TComponent : struct
{
Destroy(ReadEntity<TComponent>());
}
/// <summary>
/// Destroys all Entities containing a Component of the specified Type.
/// Entity destruction takes place after all the Engines have been processed by World Update.
/// </summary>
protected void DestroyAllWith<TComponent>() where TComponent : struct
{
foreach (var entity in ReadEntities<TComponent>())
{
Destroy(entity);
}
}
/// <summary>
/// Removes a Component with the specified type from the given Entity.
/// Note that the Engine must Read the Component type that is being removed.
/// If a Component with the specified type does not exist on the Entity, returns false and does not mutate the Entity.
/// </summary>
protected void RemoveComponent<TComponent>(in Entity entity) where TComponent : struct
{
var priority = WritePriorities.ContainsKey(typeof(TComponent)) ? WritePriorities[typeof(TComponent)] : DefaultWritePriority;
if (!WriteTypes.Contains(typeof(TComponent)))
{
throw new IllegalWriteException("Engine {0} tried to remove undeclared Component {1}. Declare with Writes attribute.", GetType().Name, typeof(TComponent).Name);
}
if (WriteImmediateTypes.Contains(typeof(TComponent)))
{
if (_componentManager.RemoveImmediate<TComponent>(entity.ID, priority))
{
_trackingManager.ImmediateUpdateTracking(entity.ID, typeof(TComponent));
}
}
else
{
_componentManager.Remove<TComponent>(entity.ID, priority);
}
if (_componentManager.HasExistingComponent<TComponent>(entity.ID))
{
_trackingManager.RegisterRemoval(entity.ID, typeof(TComponent));
}
}
/// <summary>
/// Activates the Encompass time dilation system.
/// Engines that have the IgnoresTimeDilation property will ignore all time dilation.
/// If multiple time dilations are active they will be averaged.
/// </summary>
/// <param name="factor">The time dilation factor, which is multiplied by real delta time.</param>
/// <param name="easeInTime">The time that will elapse before time is fully dilated, in real time.</param>
/// <param name="activeTime">The length of real time that time will be fully dilated.</param>
/// <param name="easeOutTime">The time that will elapse before time is fully undilated.</param>
protected void ActivateTimeDilation(double factor, double easeInTime, double activeTime, double easeOutTime)
{
_timeManager.ActivateTimeDilation(factor, easeInTime, activeTime, easeOutTime);
}
/// <summary>
/// Activates the Encompass time dilation system.
/// Engines that have the IgnoresTimeDilation property will ignore all time dilation.
/// If multiple time dilations are active they will be averaged.
/// </summary>
/// <param name="factor">The time dilation factor, which is multiplied by real delta time.</param>
/// <param name="easeInTime">The time that will elapse before time is fully dilated, in real time.</param>
/// <param name="easeInFunction">An easing function for the easing in of time dilation.</param>
/// <param name="activeTime">The length of real time that time will be fully dilated.</param>
/// <param name="easeOutTime">The time that will elapse before time is fully undilated.</param>
protected void ActivateTimeDilation(double factor, double easeInTime, System.Func<double, double, double, double, double> easeInFunction, double activeTime, double easeOutTime)
{
_timeManager.ActivateTimeDilation(factor, easeInTime, easeInFunction, activeTime, easeOutTime);
}
/// <summary>
/// Activates the Encompass time dilation system.
/// Engines that have the IgnoresTimeDilation property will ignore all time dilation.
/// If multiple time dilations are active they will be averaged.
/// </summary>
/// <param name="factor">The time dilation factor, which is multiplied by real delta time.</param>
/// <param name="easeInTime">The time that will elapse before time is fully dilated, in real time.</param>
/// <param name="activeTime">The length of real time that time will be fully dilated.</param>
/// <param name="easeOutTime">The time that will elapse before time is fully undilated.</param>
/// <param name="easeOutFunction">An easing function for the easing out of time dilation.</param>
protected void ActivateTimeDilation(double factor, double easeInTime, double activeTime, double easeOutTime, System.Func<double, double, double, double, double> easeOutFunction)
{
_timeManager.ActivateTimeDilation(factor, easeInTime, activeTime, easeOutTime, easeOutFunction);
}
/// <summary>
/// Activates the Encompass time dilation system.
/// Engines that have the IgnoresTimeDilation property will ignore all time dilation.
/// If multiple time dilations are active they will be averaged.
/// </summary>
/// <param name="factor">The time dilation factor, which is multiplied by real delta time.</param>
/// <param name="easeInTime">The time that will elapse before time is fully dilated, in real time.</param>
/// <param name="easeInFunction">An easing function for the easing in of time dilation.</param>
/// <param name="activeTime">The length of real time that time will be fully dilated.</param>
/// <param name="easeOutTime">The time that will elapse before time is fully undilated.</param>
/// <param name="easeOutFunction">An easing function for the easing out of time dilation.</param>
protected void ActivateTimeDilation(double factor, double easeInTime, System.Func<double, double, double, double, double> easeInFunction, double activeTime, double easeOutTime, System.Func<double, double, double, double, double> easeOutFunction)
{
_timeManager.ActivateTimeDilation(factor, easeInTime, easeInFunction, activeTime, easeOutTime, easeOutFunction);
}
/// <summary>
/// Efficiently reads Messages of a given type that all reference the given Entity.
/// </summary>
/// <typeparam name="TMessage">The Message subtype.</typeparam>
/// <param name="entity">The entity that all messages in the IEnumerable refer to.</param>
/// <returns></returns>
protected IEnumerable<TMessage> ReadMessagesWithEntity<TMessage>(in Entity entity) where TMessage : struct, IHasEntity
{
CheckMessageRead<TMessage>();
return _messageManager.WithEntity<TMessage>(entity.ID);
}
/// <summary>
/// Efficiently reads a single Message of a given type that references a given Entity.
/// It is recommended to use this method in conjunction with SomeMessageWithEntity to prevent errors.
/// </summary>
protected ref readonly TMessage ReadMessageWithEntity<TMessage>(in Entity entity) where TMessage : struct, IHasEntity
{
CheckMessageRead<TMessage>();
return ref _messageManager.WithEntitySingular<TMessage>(entity.ID);
}
/// <summary>
/// Efficiently checks if any Message of a given type referencing a given Entity exists.
/// </summary>
protected bool SomeMessageWithEntity<TMessage>(in Entity entity) where TMessage : struct, IHasEntity
{
CheckMessageRead<TMessage>();
return _messageManager.SomeWithEntity<TMessage>(entity.ID);
}
internal void CheckAndUpdateTracking(int entityID)
{
if (_trackedEntities.Contains(entityID) && !_entityQuery.CheckEntity(entityID, _componentManager.ExistingBits))
{
_trackedEntities.Remove(entityID);
}
else if (!_trackedEntities.Contains(entityID) && _entityQuery.CheckEntity(entityID, _componentManager.ExistingBits))
{
_trackedEntities.Add(entityID);
}
}
internal void ImmediateCheckAndUpdateTracking(int entityID)
{
if (_trackedEntities.Contains(entityID) && !_entityQuery.ImmediateCheckEntity(entityID, _componentManager.ImmediateBits, _componentManager.ExistingBits))
{
_trackedEntities.Remove(entityID);
}
else if (!_trackedEntities.Contains(entityID) && _entityQuery.ImmediateCheckEntity(entityID, _componentManager.ImmediateBits, _componentManager.ExistingBits))
{
_trackedEntities.Add(entityID);
}
}
/// <summary>
/// Returns an empty EntitySetQuery. Can be modified and iterated over to obtain Entities that fit the given criteria.
/// </summary>
internal void BuildEntityQuery()
{
var withMask = BitSet512.Zero;
foreach (var type in QueryWithTypes)
{
if (!_componentManager.TypeToIndex.ContainsKey(type)) { _componentManager.TypeToIndex.Add(type, _componentManager.TypeToIndex.Count); }
withMask = withMask.Set(_componentManager.TypeToIndex[type]);
}
var withoutMask = BitSet512.Zero;
foreach (var type in QueryWithoutTypes)
{
if (!_componentManager.TypeToIndex.ContainsKey(type)) { _componentManager.TypeToIndex.Add(type, _componentManager.TypeToIndex.Count); }
withoutMask = withoutMask.Set(_componentManager.TypeToIndex[type]);
}
var immediateMask = BitSet512.Zero;
foreach (var type in ReadImmediateTypes)
{
if (!_componentManager.TypeToIndex.ContainsKey(type)) { _componentManager.TypeToIndex.Add(type, _componentManager.TypeToIndex.Count); }
immediateMask = immediateMask.Set(_componentManager.TypeToIndex[type]);
}
var existingMask = BitSet512.Zero;
foreach (var type in ReadTypes)
{
if (!_componentManager.TypeToIndex.ContainsKey(type)) { _componentManager.TypeToIndex.Add(type, _componentManager.TypeToIndex.Count); }
existingMask = existingMask.Set(_componentManager.TypeToIndex[type]);
}
_entityQuery = new EntitySetQuery(
withMask & immediateMask,
withMask & existingMask,
withoutMask & immediateMask,
withoutMask & existingMask,
~withMask
);
}
internal void RegisterDestroyedEntity(int entityID)
{
_trackedEntities.Remove(entityID);
}
}
}