ReactiveSystem(Pool pool, IReactiveExecuteSystem subSystem, TriggerOnEvent[] triggers)
{
_subsystem = subSystem;
var ensureComponents = subSystem as IEnsureComponents;
if (ensureComponents != null)
{
_ensureComponents = ensureComponents.ensureComponents;
}
var excludeComponents = subSystem as IExcludeComponents;
if (excludeComponents != null)
{
_excludeComponents = excludeComponents.excludeComponents;
}
_clearAfterExecute = (subSystem as IClearReactiveSystem) != null;
var triggersLength = triggers.Length;
var groups = new Group[triggersLength];
var eventTypes = new GroupEventType[triggersLength];
for (int i = 0; i < triggersLength; i++)
{
var trigger = triggers[i];
groups[i] = pool.GetGroup(trigger.trigger);
eventTypes[i] = trigger.eventType;
}
_observer = new GroupObserver(groups, eventTypes);
_buffer = new List <Entity>();
}
/// This is the recommended way to create systems.
/// It will inject the pool if ISetPool is implemented.
/// It will inject the pools if ISetPools is implemented.
/// It will automatically create a ReactiveSystem if it is a
/// IReactiveSystem, IMultiReactiveSystem or IEntityCollectorSystem.
public static ISystem CreateSystem(this Pool pool,
IReactiveExecuteSystem system,
Pools pools)
{
SetPool(system, pool);
SetPools(system, pools);
var reactiveSystem = system as IReactiveSystem;
if (reactiveSystem != null)
{
return(new ReactiveSystem(pool, reactiveSystem));
}
var multiReactiveSystem = system as IMultiReactiveSystem;
if (multiReactiveSystem != null)
{
return(new ReactiveSystem(pool, multiReactiveSystem));
}
var entityCollectorSystem = system as IEntityCollectorSystem;
if (entityCollectorSystem != null)
{
return(new ReactiveSystem(entityCollectorSystem));
}
throw new EntitasException(
"Could not create ReactiveSystem for " + system + "!",
"The system has to implement IReactiveSystem, " +
"IMultiReactiveSystem or IEntityCollectorSystem."
);
}
ReactiveSystem(Pool pool, IReactiveExecuteSystem subSystem, TriggerOnEvent[] triggers)
{
_subsystem = subSystem;
var ensureComponents = subSystem as IEnsureComponents;
if (ensureComponents != null) {
_ensureComponents = ensureComponents.ensureComponents;
}
var excludeComponents = subSystem as IExcludeComponents;
if (excludeComponents != null) {
_excludeComponents = excludeComponents.excludeComponents;
}
_clearAfterExecute = (subSystem as IClearReactiveSystem) != null;
var triggersLength = triggers.Length;
var groups = new Group[triggersLength];
var eventTypes = new GroupEventType[triggersLength];
for (int i = 0; i < triggersLength; i++) {
var trigger = triggers[i];
groups[i] = pool.GetGroup(trigger.trigger);
eventTypes[i] = trigger.eventType;
}
_observer = new GroupObserver(groups, eventTypes);
_buffer = new List<Entity>();
}
ReactiveSystem(Pool pool, IReactiveExecuteSystem subSystem, IMatcher[] triggers, GroupEventType[] eventTypes)
{
_subsystem = subSystem;
var groups = new Group[triggers.Length];
for (int i = 0, triggersLength = triggers.Length; i < triggersLength; i++) {
groups[i] = pool.GetGroup(triggers[i]);
}
_observer = new GroupObserver(groups, eventTypes);
_buffer = new List<Entity>();
}
ReactiveSystem(Pool pool, IReactiveExecuteSystem subSystem, IMatcher[] triggers, GroupEventType[] eventTypes)
{
_subsystem = subSystem;
var groups = new Group[triggers.Length];
for (int i = 0, triggersLength = triggers.Length; i < triggersLength; i++)
{
groups[i] = pool.GetGroup(triggers[i]);
}
_observer = new GroupObserver(groups, eventTypes);
_buffer = new List <Entity>();
}
/// This is the recommended way to create systems.
/// It will inject the pools if ISetPools is implemented.
/// It will automatically create a ReactiveSystem if it is a IEntityCollectorSystem.
public static ISystem CreateSystem(this Pools pools, IReactiveExecuteSystem system)
{
SetPools(system, pools);
var entityCollectorSystem = system as IEntityCollectorSystem;
if (entityCollectorSystem != null)
{
return(new ReactiveSystem(entityCollectorSystem));
}
throw new EntitasException(
"Could not create ReactiveSystem for " + system + "!",
"Only IEntityCollectorSystem is supported for pools.CreateSystem(system)."
);
}
ReactiveSystem(IReactiveExecuteSystem subSystem, GroupObserver groupObserver)
{
_subsystem = subSystem;
var ensureComponents = subSystem as IEnsureComponents;
if (ensureComponents != null) {
_ensureComponents = ensureComponents.ensureComponents;
}
var excludeComponents = subSystem as IExcludeComponents;
if (excludeComponents != null) {
_excludeComponents = excludeComponents.excludeComponents;
}
_clearAfterExecute = (subSystem as IClearReactiveSystem) != null;
_observer = groupObserver;
_buffer = new List<Entity>();
}
ReactiveSystem(Pool pool, IReactiveExecuteSystem subSystem, IMatcher[] triggers, GroupEventType[] eventTypes)
{
_subsystem = subSystem;
var ensureComponents = subSystem as IEnsureComponents;
if (ensureComponents != null) {
_ensureComponents = ensureComponents.ensureComponents;
}
var excludeComponents = subSystem as IExcludeComponents;
if (excludeComponents != null) {
_excludeComponents = excludeComponents.excludeComponents;
}
var groups = new Group[triggers.Length];
for (int i = 0, triggersLength = triggers.Length; i < triggersLength; i++) {
groups[i] = pool.GetGroup(triggers[i]);
}
_observer = new GroupObserver(groups, eventTypes);
_buffer = new List<Entity>();
}
ReactiveSystem(IReactiveExecuteSystem subSystem, GroupObserver groupObserver)
{
_subsystem = subSystem;
var ensureComponents = subSystem as IEnsureComponents;
if (ensureComponents != null)
{
_ensureComponents = ensureComponents.ensureComponents;
}
var excludeComponents = subSystem as IExcludeComponents;
if (excludeComponents != null)
{
_excludeComponents = excludeComponents.excludeComponents;
}
_clearAfterExecute = (subSystem as IClearReactiveSystem) != null;
_observer = groupObserver;
_buffer = new List <Entity>();
}
ReactiveSystem(IReactiveExecuteSystem subSystem, EntityCollector collector)
{
_subsystem = subSystem;
var ensureComponents = subSystem as IEnsureComponents;
if (ensureComponents != null)
{
_ensureComponents = ensureComponents.ensureComponents;
}
var excludeComponents = subSystem as IExcludeComponents;
if (excludeComponents != null)
{
_excludeComponents = excludeComponents.excludeComponents;
}
_clearAfterExecute = (subSystem as IClearReactiveSystem) != null;
_collector = collector;
_buffer = new List <Entity>();
}
ReactiveSystem(Pool pool, IReactiveExecuteSystem subSystem, IMatcher[] triggers, GroupEventType[] eventTypes)
{
_subsystem = subSystem;
var ensureComponents = subSystem as IEnsureComponents;
if (ensureComponents != null)
{
_ensureComponents = ensureComponents.ensureComponents;
}
var excludeComponents = subSystem as IExcludeComponents;
if (excludeComponents != null)
{
_excludeComponents = excludeComponents.excludeComponents;
}
var groups = new Group[triggers.Length];
for (int i = 0, triggersLength = triggers.Length; i < triggersLength; i++)
{
groups[i] = pool.GetGroup(triggers[i]);
}
_observer = new GroupObserver(groups, eventTypes);
_buffer = new List <Entity>();
}
/// This is the recommended way to create systems.
/// It will inject the pool if ISetPool is implemented.
/// It will inject the pools if ISetPools is implemented.
/// It will automatically create a ReactiveSystem if it is a
/// IReactiveSystem, IMultiReactiveSystem or IEntityCollectorSystem.
public static ISystem CreateSystem(this Pool pool,
IReactiveExecuteSystem system)
{
return(CreateSystem(pool, system, Pools.sharedInstance));
}
