Beispiel #1
0
        protected virtual void RegisterModules()
        {
            //   DependencyContainer.LoadModule<FrameworkModule>();
            var mess = new EcsRx.Reactive.MessageBroker();

            // DependencyContainer.Resolve<ISystemExecutor>();
            EventSystem = new EventSystem(mess);// DependencyContainer.Resolve<IEventSystem>();

            var factory  = new Entities.DefaultEntityFactory(EventSystem);
            var factory2 = new DefaultEntityCollectionFactory(factory, EventSystem);
            var ob       = new Groups.Observable.DefaultObservableObservableGroupFactory(EventSystem);

            EntityCollectionManager = new EntityCollectionManager(EventSystem, factory2, ob);
            var handler = new List <IConventionalSystemHandler>();

            handler.Add(new ReactToEntitySystemHandler(EntityCollectionManager));
            handler.Add(new ReactToGroupSystemHandler(EntityCollectionManager));
            handler.Add(new ReactToDataSystemHandler(EntityCollectionManager));
            handler.Add(new ManualSystemHandler(EntityCollectionManager));
            handler.Add(new SetupSystemHandler(EntityCollectionManager));
            handler.Add(new TeardownSystemHandler(EntityCollectionManager));



            //  var def = new EntityCollection();
            // DependencyContainer.Resolve<IEntityCollectionManager>();
        }
        public void GlobalSetup()
        {
            var componentTypeAssigner = new DefaultComponentTypeAssigner();
            var allComponents         = componentTypeAssigner.GenerateComponentLookups();
            var componentLookup       = new ComponentTypeLookup(allComponents);

            _availableComponents = allComponents.Keys
                                   .Select(x => Activator.CreateInstance(x) as IComponent)
                                   .ToArray();

            var componentDatabase   = new ComponentDatabase(componentLookup);
            var componentRepository = new ComponentRepository(componentLookup, componentDatabase);

            var entityFactory          = new DefaultEntityFactory(new IdPool(), componentRepository);
            var poolFactory            = new DefaultEntityCollectionFactory(entityFactory);
            var observableGroupFactory = new DefaultObservableObservableGroupFactory();

            _entityCollectionManager = new EntityCollectionManager(poolFactory, observableGroupFactory, componentLookup);

            _availableComponents = _groupFactory.GetComponentTypes
                                   .Select(x => Activator.CreateInstance(x) as IComponent)
                                   .ToArray();

            _testGroups = _groupFactory.CreateTestGroups().ToArray();

            foreach (var group in _testGroups)
            {
                _entityCollectionManager.GetObservableGroup(group);
            }

            _defaultEntityCollection = _entityCollectionManager.GetCollection();
        }
        private IEntityCollectionManager CreateCollectionManager()
        {
            var messageBroker        = new EventSystem(new MessageBroker());
            var entityFactory        = new DefaultEntityFactory(messageBroker);
            var collectionFactory    = new DefaultEntityCollectionFactory(entityFactory, messageBroker);
            var groupAccessorFactory = new DefaultObservableObservableGroupFactory(messageBroker);

            return(new EntityCollectionManager(messageBroker, collectionFactory, groupAccessorFactory));
        }
Beispiel #4
0
        private IEntityCollectionManager CreateCollectionManager()
        {
            var componentLookups = new Dictionary <Type, int>
            {
                { typeof(TestComponentOne), 0 },
                { typeof(TestComponentTwo), 1 },
                { typeof(TestComponentThree), 2 }
            };
            var componentLookupType    = new ComponentTypeLookup(componentLookups);
            var componentDatabase      = new ComponentDatabase(componentLookupType);
            var componentRepository    = new ComponentRepository(componentLookupType, componentDatabase);
            var entityFactory          = new DefaultEntityFactory(new IdPool(), componentRepository);
            var collectionFactory      = new DefaultEntityCollectionFactory(entityFactory);
            var observableGroupFactory = new DefaultObservableObservableGroupFactory();

            return(new EntityCollectionManager(collectionFactory, observableGroupFactory, componentLookupType));
        }
Beispiel #5
0
        protected EcsRxApplication()
        {
            // For sending events around
            EventSystem = new EventSystem(new MessageBroker());

            // For mapping component types to underlying indexes
            var componentTypeAssigner = new DefaultComponentTypeAssigner();
            var allComponents         = componentTypeAssigner.GenerateComponentLookups();

            var componentLookup = new ComponentTypeLookup(allComponents);
            // For interacting with the component databases
            var componentDatabase   = new ComponentDatabase(componentLookup);
            var componentRepository = new ComponentRepository(componentLookup, componentDatabase);

            // For creating entities, collections, observable groups and managing Ids
            var entityFactory           = new DefaultEntityFactory(new IdPool(), componentRepository);
            var entityCollectionFactory = new DefaultEntityCollectionFactory(entityFactory);
            var observableGroupFactory  = new DefaultObservableObservableGroupFactory();

            EntityCollectionManager = new EntityCollectionManager(entityCollectionFactory, observableGroupFactory, componentLookup);

            // All system handlers for the system types you want to support
            var reactsToEntityHandler = new ReactToEntitySystemHandler(EntityCollectionManager);
            var reactsToGroupHandler  = new ReactToGroupSystemHandler(EntityCollectionManager);
            var reactsToDataHandler   = new ReactToDataSystemHandler(EntityCollectionManager);
            var manualSystemHandler   = new ManualSystemHandler(EntityCollectionManager);
            var setupHandler          = new SetupSystemHandler(EntityCollectionManager);
            var teardownHandler       = new TeardownSystemHandler(EntityCollectionManager);

            var conventionalSystems = new List <IConventionalSystemHandler>
            {
                setupHandler,
                teardownHandler,
                reactsToEntityHandler,
                reactsToGroupHandler,
                reactsToDataHandler,
                manualSystemHandler
            };

            // The main executor which manages how systems are given information
            SystemExecutor = new SystemExecutor(conventionalSystems);
        }
Beispiel #6
0
        private (IEntityCollectionManager, IComponentDatabase, IComponentTypeLookup) CreateFramework()
        {
            var componentLookups = new Dictionary <Type, int>
            {
                { typeof(TestComponentOne), 0 },
                { typeof(TestComponentTwo), 1 },
                { typeof(TestComponentThree), 2 },
                { typeof(ViewComponent), 3 },
                { typeof(TestStructComponentOne), 4 },
                { typeof(TestStructComponentTwo), 5 }
            };
            var componentLookupType    = new ComponentTypeLookup(componentLookups);
            var componentDatabase      = new ComponentDatabase(componentLookupType);
            var entityFactory          = new DefaultEntityFactory(new IdPool(), componentDatabase, componentLookupType);
            var collectionFactory      = new DefaultEntityCollectionFactory(entityFactory);
            var observableGroupFactory = new DefaultObservableObservableGroupFactory();
            var collectionManager      = new EntityCollectionManager(collectionFactory, observableGroupFactory, componentLookupType);

            return(collectionManager, componentDatabase, componentLookupType);
        }
        public void GlobalSetup()
        {
            _eventSystem = new EventSystem(new MessageBroker());

            var entityFactory        = new DefaultEntityFactory(_eventSystem);
            var poolFactory          = new DefaultEntityCollectionFactory(entityFactory, _eventSystem);
            var groupAccessorFactory = new DefaultObservableObservableGroupFactory(_eventSystem);

            _entityCollectionManager = new EntityCollectionManager(_eventSystem, poolFactory, groupAccessorFactory);

            _availableComponents = _groupFactory.GetComponentTypes
                                   .Select(x => Activator.CreateInstance(x) as IComponent)
                                   .ToArray();

            _testGroups = _groupFactory.CreateTestGroups().ToArray();

            foreach (var group in _testGroups)
            {
                _entityCollectionManager.CreateObservableGroup(group);
            }

            _defaultEntityCollection = _entityCollectionManager.GetCollection();
        }