static void animatingComponent(Pool pool)
 {
     var e = pool.animatingEntity;
     var isAnimating = pool.isAnimating;
     pool.isAnimating = true;
     pool.isAnimating = false;
 }

        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>();
        }

 public void SetPool(Pool pool)
 {
     _pool = pool;
     _asteroids = pool.GetGroup(Matcher.Asteroid);
     _levels = pool.GetGroup(Matcher.Level);
     _players = pool.GetGroup(Matcher.Player);
 }

        private Systems CreateSystems(Pool pool)
        {
#if (UNITY_EDITOR)
            return new DebugSystems()
#else
        return new Systems()
#endif
                .Add(pool.CreateSystem<TickingSystem>())
                .Add(pool.CreateSystem<PositionUpdatingSystem>())
                .Add(pool.CreateSystem<RenderForceSystem>())
                .Add(pool.CreateSystem<BulletCollisionSystem>())
                .Add(pool.CreateSystem<AddViewSystem>())
                .Add(pool.CreateSystem<LevelStartingSystem>())
                .Add(pool.CreateSystem<SpaceshipControlsSystem>())
                .Add(pool.CreateSystem<AddRigidbodySystem>())
                .Add(pool.CreateSystem<AgingSystem>())
                .Add(pool.CreateSystem<MaxAgeSystem>())
                .Add(pool.CreateSystem<AsteroidSplittingSystem>())
                .Add(pool.CreateSystem<RenderRotationSystem>())
                .Add(pool.CreateSystem<GunFiringSystem>())
                .Add(pool.CreateSystem<GunCooldownSystem>())
                .Add(pool.CreateSystem<LevelEndingSystem>())
                .Add(pool.CreateSystem<SpaceshipRespawningSystem>())
                .Add(pool.CreateSystem<SpaceshipCollisionSystem>())
                .Add(pool.CreateSystem<InputDestructionSystem>())
                .Add(pool.CreateSystem<BoundsWrappingSystem>())
                .Add(pool.CreateSystem<RenderPositionSystem>())
                .Add(pool.CreateSystem<RemoveViewSystem>())
                .Add(pool.CreateSystem<DestroyingSystem>());
        }

 public void Init(Pool pool, Entity entity)
 {
     _pool = pool;
     _entity = entity;
     _entity.OnEntityReleased += onEntityReleased;
     Update();
 }

 static void moveSystem(Pool pool) {
     var entities = pool.GetEntities(Matcher.AllOf(Matcher.Move, Matcher.Position));
     foreach (var entity in entities) {
         var move = entity.move;
         var pos = entity.position;
         entity.ReplacePosition(pos.x, pos.y + move.speed);
     }
 }

 public void SetPool(Pool pool)
 {
     _pool = pool;
     _pool.GetGroup(Matcher.SpaceshipDeathroes).OnEntityRemoved += OnDeaththroesRemoved;
     _waiting = _pool.GetGroup(Matcher.AllOf(Matcher.WaitingForSpace, Matcher.Spaceship));
     _asteroids = pool.GetGroup(Matcher.AllOf(Matcher.Asteroid, Matcher.CollisionRadius));
     _games = _pool.GetGroup(Matcher.AllOf(Matcher.Game, Matcher.Bounds));
     _lives = _pool.GetGroup(Matcher.Lives);
 }

        public void Init(Pool pool, Entity entity)
        {
            _pool = pool;
            _entity = entity;
            _unfoldedComponents = new bool[_pool.totalComponents];
            _entity.OnComponentRemoved += onComponentRemoved;

            UnfoldAllComponents();
        }

        static void groupExample(Pool pool) {
            pool.GetGroup(Matcher.Position).GetEntities();

            // ----------------------------

            pool.GetGroup(Matcher.Position).OnEntityAdded += (group, entity) => {
                // Do something
            };
        }

 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>();
 }

        public void Init(Pool pool, Entity entity, Type[] componentTypes) {
            _pool = pool;
            _entity = entity;
            _componentTypes = componentTypes;
            componentToAdd = -1;
            _unfoldedComponents = new bool[_pool.totalComponents];
            _entity.OnEntityReleased += onEntityReleased;
            Update();

            UnfoldAllComponents();
        }

        public void Init(Pool pool, Entity entity, int debugIndex)
        {
            _pool = pool;
            _entity = entity;
            _debugIndex = debugIndex;
            _unfoldedComponents = new bool[_pool.totalComponents];
            _entity.OnComponentAdded += onEntityChanged;
            _entity.OnComponentRemoved += onEntityChanged;
            updateName();

            UnfoldAllComponents();
        }

        static void groupObserverExample(Pool pool)
        {
            var group = pool.GetGroup(Matcher.Position);
            var observer = group.CreateObserver(GroupEventType.OnEntityAdded);

            // ----------------------------
            foreach (var e in observer.collectedEntities) {
                // do something
            }
            observer.ClearCollectedEntities();

            // ----------------------------
            observer.Deactivate();
        }

        public void Start()
        {
            pool = Pools.pool;

            pool.GetGroup(EntitysToBeViewed).OnEntityAdded += (group, entity, index, component) => OnEntityAdded(entity);

            pool.GetGroup(EntitysToBeViewed).OnEntityRemoved +=
                (group, entity, index, component) => OnEntityRemoved(entity);

            pool.GetGroup(Matcher.GameState).OnEntityAdded +=
                (group, entity, index, component) => OnGameStateUpdated(entity.gameState.GameState);

            tableContents = new Dictionary<int, GameObject>();
        }

 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>();
 }

 public static Systems GetSystems(Pool pool)
 {
     #if (UNITY_EDITOR)
     return new DebugSystems()
     #else
         return new Systems()
     #endif
         // Initialize
         .Add(pool.CreateSystem<RemoveViewSystem>())
         .Add(pool.CreateSystem<AddViewSystem>())
         .Add(pool.CreateSystem<CreatePilotsSystem>())
         .Add(pool.CreateSystem<StartGameSystem>())
         .Add(pool.CreateSystem<CreateEventsSystem>())
         .Add(pool.CreateSystem<CreateAircraftSystem>())
         .Add(pool.CreateSystem<PauseSystem>())
         .Add(pool.CreateSystem<TimeSystem>())
         .Add(pool.CreateSystem<UINavigationSystem>())
         .Add(pool.CreateSystem<EventPredicateCheckingSystem>())
         .Add(pool.CreateSystem<EventResolutionSystem>());
 }

        public static void DrawComponents(Pool pool, Entity entity)
        {
            bool[] unfoldedComponents;
            if (!_poolToUnfoldedComponents.TryGetValue(pool, out unfoldedComponents)) {
                unfoldedComponents = new bool[pool.totalComponents];
                for (int i = 0; i < unfoldedComponents.Length; i++) {
                    unfoldedComponents[i] = true;
                }
                _poolToUnfoldedComponents.Add(pool, unfoldedComponents);
            }

            EntitasEditorLayout.BeginVerticalBox();
            {
                EntitasEditorLayout.BeginHorizontal();
                {
                    EditorGUILayout.LabelField("Components (" + entity.GetComponents().Length + ")", EditorStyles.boldLabel);
                    if (GUILayout.Button("▸", GUILayout.Width(21), GUILayout.Height(14))) {
                        for (int i = 0; i < unfoldedComponents.Length; i++) {
                            unfoldedComponents[i] = false;
                        }
                    }
                    if (GUILayout.Button("▾", GUILayout.Width(21), GUILayout.Height(14))) {
                        for (int i = 0; i < unfoldedComponents.Length; i++) {
                            unfoldedComponents[i] = true;
                        }
                    }
                }
                EntitasEditorLayout.EndHorizontal();

                EditorGUILayout.Space();

                var componentNames = entity.poolMetaData.componentNames;
                var index = EditorGUILayout.Popup("Add Component", -1, componentNames);
                if (index >= 0) {
                    var componentType = entity.poolMetaData.componentTypes[index];
                    var component = (IComponent)Activator.CreateInstance(componentType);
                    entity.AddComponent(index, component);
                }

                EditorGUILayout.Space();

                EntitasEditorLayout.BeginHorizontal();
                {
                    _componentNameSearchTerm = EditorGUILayout.TextField("Search", _componentNameSearchTerm);

                    const string clearButtonControlName = "Clear Button";
                    GUI.SetNextControlName(clearButtonControlName);
                    if (GUILayout.Button("x", GUILayout.Width(19), GUILayout.Height(14))) {
                        _componentNameSearchTerm = string.Empty;
                        GUI.FocusControl(clearButtonControlName);
                    }
                }
                EntitasEditorLayout.EndHorizontal();

                EditorGUILayout.Space();

                var indices = entity.GetComponentIndices();
                var components = entity.GetComponents();
                for (int i = 0; i < components.Length; i++) {
                    DrawComponent(unfoldedComponents, entity, indices[i], components[i]);
                }
            }
            EntitasEditorLayout.EndVertical();
        }

        static void userComponent(Pool pool, UserComponent component)
        {
            var e = pool.userEntity;
            var name = pool.user.name;
            var has = pool.hasUser;

            pool.SetUser("John", 42);
            pool.SetUser(component);

            pool.ReplaceUser("Max", 24);

            pool.RemoveUser();
        }

 public void SetPool(Pool pool)
 {
     systemPool = pool;
 }

 void switchToPool()
 {
     if (_pool != null) {
         _pool.Reset();
     }
     var targetPool = _allPools[_poolIndex];
     _pool = new Pool(targetPool.totalComponents, 0, targetPool.metaData);
     _entity = _pool.CreateEntity();
 }