Пример #1
0
        public int GetFutureComponentIdx(IComponent component)
        {
            var typeId = component.TypeId;
            var id     = _componentIndex.GetTypeIndex(component.TypeId);

            if (id == -1)
            {
                // компонент не содержится в текущем реакторе.
                // Данная ветка необходима для определение "будущего" идентификатора в следующем реакторе
                ReactorConnection connection;
                if (!_outConnectionIndex.TryGetValue(typeId, out connection))
                {
                    var typeList = new List <Type>(TargetTypesSet)
                    {
                        component.Type
                    };
                    SystemReactor nextReactor = _systemExecutor.GetOrCreateConcreteSystemReactor(typeList);
                    connection = new ReactorConnection(component.Type, nextReactor, this);
                    _outConnectionIndex.Add(component, connection);
                    nextReactor._inConnectionIndex.Add(component, connection);
                }
                id = connection.UpReactor.GetComponentIdx(typeId);
            }
            return(id);
        }
Пример #2
0
 public void AddReactorsConnection(Type componenType, ReactorConnection connection, SystemReactor reactor)
 {
     if (!_connections.ContainsKey(componenType))
     {
         _connections.Add(componenType, connection);
         reactor.AddReactorsConnection(componenType, connection, this);
     }
 }
Пример #3
0
        public bool TryGetValue(int typeId, out ReactorConnection connection)
        {
            var idx = _index.GetTypeIndex(typeId);

            if (-1 < idx && idx < _connections.Length)
            {
                connection = _connections[idx];
                return(connection != null);
            }
            connection = null;
            return(false);
        }
Пример #4
0
        public void RemoveComponent(IEntity entity, Type componenType)
        {
            ReactorConnection connection;

            if (!_connections.TryGetValue(componenType, out connection))
            {
                var           set     = new HashSet <Type>(TargetTypes);
                SystemReactor reactor = _systemExecutor.GetSystemReactor(set);
                connection = new ReactorConnection(this, reactor);
                this.AddReactorsConnection(componenType, connection, reactor);
            }
            entity.Reactor = connection.DownReactor;
            _systemExecutor.RemoveSystemsFromEntity(entity, connection);
        }
Пример #5
0
        public void RemoveComponent(IEntity entity, IComponent component)
        {
            var typeId = component.TypeId;

            if (!_inConnectionIndex.TryGetValue(typeId, out var connection))
            {
                var typeList = new List <Type>(TargetTypesSet);
                typeList.Remove(component.Type);
                SystemReactor prevReactor = _systemExecutor.GetOrCreateConcreteSystemReactor(typeList);
                connection = new ReactorConnection(component.Type, this, prevReactor);
                _inConnectionIndex.Add(component, connection);
                prevReactor._outConnectionIndex.Add(component, connection);
            }
            _systemExecutor.RemoveSystemsFromEntity(entity, connection);
            entity.Reactor = connection.DownReactor;
        }
Пример #6
0
        public void AddComponent(IEntity entity, Type componenType)
        {
            ReactorConnection connection;

            if (!_connections.TryGetValue(componenType, out connection))
            {
                var set = new HashSet <Type>(TargetTypes)
                {
                    componenType
                };
                SystemReactor reactor = _systemExecutor.GetSystemReactor(set);
                connection = new ReactorConnection(reactor, this);
                this.AddReactorsConnection(componenType, connection, reactor);
            }
            entity.Reactor = connection.UpReactor;
            _systemExecutor.AddSystemsToEntity(entity, connection);
        }
Пример #7
0
        public void AddComponent(IEntity entity, IComponent component)
        {
            var typeId = component.TypeId;

            if (!_outConnectionIndex.TryGetValue(typeId, out var connection))
            {
                var typeList = new List <Type>(TargetTypesSet)
                {
                    component.Type
                };
                SystemReactor nextReactor = _systemExecutor.GetOrCreateConcreteSystemReactor(typeList);
                connection = new ReactorConnection(component.Type, nextReactor, this);
                _outConnectionIndex.Add(component, connection);
                nextReactor._inConnectionIndex.Add(component, connection);
            }
            entity.Reactor = connection.UpReactor;
            _systemExecutor.AddSystemsToEntity(entity, connection);
        }
Пример #8
0
        public void Add(IComponent component, ReactorConnection connection)
        {
            if (!_index.HasIndex(component.TypeId))
            {
                _index.AddToIndex(component.Type);
                _index.Build();
            }

            var idx = _index.GetTypeIndex(component.TypeId);

            if (idx >= _connections.Length)
            {
                Array.Resize(ref _connections, idx + 1);
            }

            if (_connections[idx] == null)
            {
                _connections[idx] = connection;
            }
        }