Entitas1.5.2类图及源码解析

一、类图

这里对主要类进行了类图描述，只能反应一个大概的关系网，具体运行原理需要读源码。

二、关键代码解析

1. Context.cs

   /// Creates a new entity or gets a reusable entity from the
   /// internal ObjectPool for entities.
   public TEntity CreateEntity() {
       TEntity entity;
   
       if (_reusableEntities.Count > 0) {
           entity = _reusableEntities.Pop();
           entity.Reactivate(_creationIndex++);
       } else {
           entity = (TEntity)Activator.CreateInstance(typeof(TEntity));
           entity.Initialize(_creationIndex++, _totalComponents, _componentPools, _contextInfo, _aercFactory(entity));
       }
   
       _entities.Add(entity);
       entity.Retain(this);
       _entitiesCache = null;
   
       entity.OnComponentAdded += _cachedEntityChanged;
       entity.OnComponentRemoved += _cachedEntityChanged;
       entity.OnComponentReplaced += _cachedComponentReplaced;
       entity.OnEntityReleased += _cachedEntityReleased;
       entity.OnDestroyEntity += _cachedDestroyEntity;
   
       if (OnEntityCreated != null) {
           OnEntityCreated(this, entity);
       }
   
       return entity;
   }

   在该环境下创建Entity，注册事件，这样当Component变化时，会触发Entity相应的Handler。

2. Context.cs

   /// Returns a group for the specified matcher.
   /// Calling context.GetGroup(matcher) with the same matcher will always
   /// return the same instance of the group.
   public IGroup<TEntity> GetGroup(IMatcher<TEntity> matcher) {
       IGroup<TEntity> group;
       if (!_groups.TryGetValue(matcher, out group)) {
           group = new Group<TEntity>(matcher);
           var entities = GetEntities();
           for (int i = 0; i < entities.Length; i++) {
               group.HandleEntitySilently(entities[i]);
           }
           _groups.Add(matcher, group);
   
           for (int i = 0; i < matcher.indices.Length; i++) {
               var index = matcher.indices[i];
               if (_groupsForIndex[index] == null) {
                   _groupsForIndex[index] = new List<IGroup<TEntity>>();
               }
               _groupsForIndex[index].Add(group);
           }
   
           if (OnGroupCreated != null) {
               OnGroupCreated(this, group);
           }
       }
   
       return group;
   }

   获取匹配组，没有就创建，同时还要维护每个组件对应的所有Group集合，就是说只要这个Group要收集包含该组件的Entity就得加入到这个集合里。

3. Context.cs

   void updateGroupsComponentAddedOrRemoved(IEntity entity, int index, IComponent component) {
       var groups = _groupsForIndex[index];
        if (groups != null) {
            var events = _groupChangedListPool.Get();
   
            var tEntity = (TEntity)entity;
   
            for (int i = 0; i < groups.Count; i++) {
                events.Add(groups[i].HandleEntity(tEntity));
            }
   
            for (int i = 0; i < events.Count; i++) {
                var groupChangedEvent = events[i];
                if (groupChangedEvent != null) {
                    groupChangedEvent(
                        groups[i], tEntity, index, component
                    );
                }
            }
   
            _groupChangedListPool.Push(events);
        }
    }
   
   //Group.cs中的
   public GroupChanged<TEntity> HandleEntity(TEntity entity) {
        return _matcher.Matches(entity)
           ? (addEntitySilently(entity) ? OnEntityAdded : null)
           : (removeEntitySilently(entity) ? OnEntityRemoved : null);
   }

   每个Entity添加或移除组件时，先拿到该组件可能影响到的所有匹配组，然后让每个组去判断对该Entity进行添加操作还是删除，然后再根据Collector对Group的监听类型选择是否触发Collector。

4. Collector.cs

   /// Activates the Collector and will start collecting
   /// changed entities. Collectors are activated by default.
   public void Activate() {
       for (int i = 0; i < _groups.Length; i++) {
           var group = _groups[i];
           var groupEvent = _groupEvents[i];
           switch (groupEvent) {
               case GroupEvent.Added:
                   group.OnEntityAdded -= _addEntityCache;
                   group.OnEntityAdded += _addEntityCache;
                   break;
               case GroupEvent.Removed:
                   group.OnEntityRemoved -= _addEntityCache;
                   group.OnEntityRemoved += _addEntityCache;
                   break;
               case GroupEvent.AddedOrRemoved:
                   group.OnEntityAdded -= _addEntityCache;
                   group.OnEntityAdded += _addEntityCache;
                   group.OnEntityRemoved -= _addEntityCache;
                   group.OnEntityRemoved += _addEntityCache;
                   break;
           }
       }
   }

   在构造System时，我们可能会需要一个或多个Collector，比如ReactiveSystem、MultiReactiveSystem，此时需要给Collector的构造函数传匹配组，目前都是一个Collector对应一个Group，我们可以选择监听Group变化类型，如果Add，那么只要Group中的Entity添加进来就告诉Collector，Remove情况除外，其他同理。

三、我的理解

Context，可以理解成一个环境，包含属于该环境下的所有Entity，每个Entity维护一个Component集合，同时Context还维护一个匹配组字典集，一个Match对应一个Group，匹配的意思是按照一个或多个组件类型进行筛选该环境下所有的Entity，匹配组表示属于这个匹配的所有Entity集合，System里处理逻辑，System构造之前要么构造一个Collector负责监听一个或多个匹配组（目前都是一个），要么从Context拿到某个匹配组，一旦Entity的Component的数据发生改变，就会触发相应Group发生改变，从而触发Collector维护的Entity集合发生改变，所以System就会将变化的Entity进行处理。很多的Cache这里不细说了。