Пример #1
0
        IEnumerator Respawn(ShipViewComponent shipView, EGID egid)
        {
            yield return(_respawnWait);

            Relocate(shipView, egid);

            var targetGroup = egid.groupID.SwapTag <AFLOAT>();

            if (GroupTagExtensions.Contains <PLAYER_SHIP>(egid.groupID))
            {
                _functions.SwapEntityGroup <PlayerShipDescriptor>(egid, targetGroup);
            }
            else
            {
                _functions.SwapEntityGroup <AiShipDescriptor>(egid, targetGroup);
            }

            shipView.CoinsHud.Visibility = true;

            var render = false;

            while (_transitionWait.MoveNext())
            {
                render = !render;
                shipView.Renderer.Render = render;

                yield return(_animationWait);
            }

            shipView.Renderer.Render = true;
            shipView.Physics.Enable  = true;
        }
                /// <summary>
                /// With the following code I demostrate two features:
                /// First how to move an entity between groups
                /// Second how to remove an entity from a group
                /// </summary>
                /// <param name="entity"></param>
                protected override void Add(BehaviourEntityViewForSimpleGroupedEntity entity)
                {
                    Utility.Console.Log("Grouped EntityView Added");

                    _entityFunctions.SwapEntityGroup <SimpleGroupedEntityDescriptor>(entity.ID, entity.simpleComponent.groupID, 1);
                    entity.simpleComponent.groupID = 1;
                    Utility.Console.Log("Grouped EntityView Swapped");
                    _entityFunctions.RemoveEntityFromGroup <SimpleGroupedEntityDescriptor>(entity.ID, entity.simpleComponent.groupID);
                }
Пример #3
0
        IEnumerator pedra(BattleEntityView entityView)
        {
            yield return(new WaitForSeconds(2f));

            var unitsInMap = entityViewsDB.QueryEntityViews <UnitEntityView>();

            foreach (var unitEntityView in unitsInMap)
            {
                _entityFunctions.SwapEntityGroup(unitEntityView.ID, 1, entityView.ID);
                unitEntityView.turnComponent.isInBattle = true;
            }

            entityView.battleStateComponent.state.value = BattleState.Starting;
        }
Пример #4
0
        public IEnumerator Tick()
        {
            while (true)
            {
                Process();
                yield return(null);
            }

            void Process()
            {
                var query = entitiesDB.QueryEntities <ShipComponent>(ShipGroups.AliveShipGroups);

                foreach (var((ships, count), group) in query.groups)
                {
                    for (var i = 0; i < count; i++)
                    {
                        ref var ship = ref ships[i];
                        if (!ship.IsSinking)
                        {
                            continue;
                        }

                        ship.IsSinking = false;
                        // note: This semi abstracted engine shouldn't know which descriptor it is changing.
                        var targetGroup = ship.ID.groupID.SwapTag <SUNK>();
                        if (GroupTagExtensions.Contains <PLAYER_SHIP>(ship.ID.groupID))
                        {
                            _functions.SwapEntityGroup <PlayerShipDescriptor>(ship.ID, targetGroup);
                        }
                        else
                        {
                            _functions.SwapEntityGroup <AiShipDescriptor>(ship.ID, targetGroup);
                        }
                    }
                }
            }
        public IEnumerator Tick()
        {
            _submissionWait = new WaitForSubmissionEnumerator(_functions, _entityFactory, entitiesDB);
            yield return(ReadyAllCoins());

            while (true)
            {
                yield return(_submissionWait);

                var(coins, coinViews, coinsCount) =
                    entitiesDB.QueryEntities <CoinComponent, CoinViewComponent>(CoinGroups.RecycledCoinsGroup);
                if (coinsCount == 0)
                {
                    continue;
                }

                // Advance spawn timer.
                var coinToSpawn = -1;
                for (var i = 0; i < coinsCount; i++)
                {
                    coins[i].TimeToRespawn -= _time.DeltaTime;
                    if (coins[i].TimeToRespawn > 0)
                    {
                        continue;
                    }

                    coinToSpawn = i;
                    break;
                }

                // Make sure there are available cells to drop a coin.
                var(cells, cellCount) = entitiesDB.QueryEntities <GridCellComponent>(GridGroups.GridWaterGroup);
                if (cellCount == 0 || _freeCellsFilter.filteredIndices.Count() == 0 || coinToSpawn < 0)
                {
                    continue;
                }

                // Spawn one coin if found (recycling it).
                var availableCells = _freeCellsFilter.filteredIndices;
                var selectedCell   = _random.NextUInt(0, (uint)availableCells.Count());
                var cell           = cells[availableCells.Get(selectedCell)];

                var coinView = coinViews[coinToSpawn];
                _functions.SwapEntityGroup <CoinEntityDescriptor>(coinView.ID, CoinGroups.SpawnedCoinsGroup);

                coinView.Transform.Position = new float3(cell.WorldCenter, 0);
            }
        }
                    protected override void Add(BehaviourEntityViewForEntity entity)
                    {
                        if (entity.simpleComponent.isInGroup == false)
                        {
                            Console.Log("EntityView Added");

                            _entityFunctions.RemoveEntity(entity.ID);
                        }
                        else
                        {
                            Console.Log("Grouped EntityView Added");

                            _entityFunctions.SwapEntityGroup(entity.ID, 0, 1);
                            Console.Log("Grouped EntityView Swapped");
                            _entityFunctions.RemoveEntity(entity.ID);
                        }
                    }
Пример #7
0
        public IEnumerator Tick()
        {
            while (true)
            {
                var(coins, coinViews, count) = entitiesDB.QueryEntities <CoinComponent, CoinViewComponent>(CoinGroups.SpawnedCoinsGroup);

                for (var i = 0; i < count; i++)
                {
                    if (coins[i].Picked)
                    {
                        coinViews[i].Physics.Enable = false;
                        _functions.SwapEntityGroup <CoinEntityDescriptor>(coins[i].ID, CoinGroups.RecycledCoinsGroup);
                    }
                }

                yield return(null);
            }
        }
Пример #8
0
        IEnumerator AnimateOnDeath()
        {
            while (true)
            {
                var entites =
                    entitiesDB.QueryEntities <EnemyEntityViewStruct, EnemySinkStruct, EnemyEntityStruct>(
                        ECSGroups.DeadEnemiesGroups, out var numberOfEnemies);

                var enemyEntityViewsStructs = entites.Item1;
                var enemyEntitySinkStructs  = entites.Item2;

                for (var i = 0; i < numberOfEnemies; i++)
                {
                    var animationComponent = enemyEntityViewsStructs[i].animationComponent;
                    if (animationComponent.playAnimation != "Dead")
                    {
                        animationComponent.playAnimation        = "Dead";
                        enemyEntitySinkStructs[i].animationTime = DateTime.UtcNow.AddSeconds(2);
                    }
                    else
                    {
                        if (DateTime.UtcNow < enemyEntitySinkStructs[i].animationTime)
                        {
                            enemyEntityViewsStructs[i].transformComponent.position =
                                enemyEntityViewsStructs[i].positionComponent.position + -Vector3.up *
                                enemyEntitySinkStructs[i].sinkAnimSpeed * _time.deltaTime;
                        }
                        else
                        {
                            var enemyStructs = entites.Item3;

                            _entityFunctions.SwapEntityGroup <EnemyEntityDescriptor>(enemyEntityViewsStructs[i].ID,
                                                                                     ECSGroups.EnemiesToRecycleGroups +
                                                                                     (uint)enemyStructs[i].enemyType);

                            _enemyDeadSequencer.Next(this, enemyEntityViewsStructs[i].ID);
                        }
                    }
                }

                yield return(null);
            }
        }
Пример #9
0
        /// <summary>
        ///     Reset all the component values when an Enemy is ready to be recycled.
        ///     it's important to not forget to reset all the states.
        ///     note that the only reason why we pool it the entities here is to reuse the implementors,
        ///     pure entity structs entities do not need pool and can be just recreated
        /// </summary>
        /// <param name="spawnData"></param>
        /// <returns></returns>
        void ReuseEnemy(ExclusiveGroup.ExclusiveGroupStruct fromGroupId, JSonEnemySpawnData spawnData)
        {
            var healths = entitiesDB.QueryEntities <HealthEntityStruct>(fromGroupId, out var count);

            if (count > 0)
            {
                var enemystructs = entitiesDB.QueryEntities <EnemyEntityViewStruct>(fromGroupId, out count);
                healths[0].currentHealth = 100;
                healths[0].dead          = false;

                var spawnInfo = spawnData.enemySpawnData.spawnPoint;

                enemystructs[0].transformComponent.position           = spawnInfo;
                enemystructs[0].movementComponent.navMeshEnabled      = true;
                enemystructs[0].movementComponent.setCapsuleAsTrigger = false;
                enemystructs[0].layerComponent.layer     = GAME_LAYERS.ENEMY_LAYER;
                enemystructs[0].animationComponent.reset = true;

                _entityFunctions.SwapEntityGroup <EnemyEntityDescriptor>(enemystructs[0].ID, ECSGroups.ActiveEnemies);
            }
        }
        IEnumerator CheckIfDead()
        {
            while (true)
            {
                //wait for enemies to be created
                while (entitiesDB.HasAny <EnemyEntityStruct>(ECSGroups.ActiveEnemies) == false)
                {
                    yield return(null);
                }

                //Groups affect the memory layout. Entity views are split according groups, so that even if entity
                //views are used by entities outside a specific group, those entity views won't be present
                //in the array returned by QueryEntities.
                var entities =
                    entitiesDB.QueryEntities <EnemyEntityViewStruct, HealthEntityStruct, EnemyAttackStruct>(
                        ECSGroups.ActiveEnemies, out var count);

                var enemyEntitiesHealth = entities.Item2;
                var enemyEntitiesViews  = entities.Item1;
                var enemyAttackStruct   = entities.Item3;

                for (var index = 0; index < count; index++)
                {
                    if (enemyEntitiesHealth[index].dead == false)
                    {
                        continue;
                    }

                    SetParametersForDeath(ref enemyEntitiesViews[index], ref enemyAttackStruct[index]);

                    _enemyDeadSequencer.Next(this, enemyEntitiesViews[index].ID);
                    _entityFunctions.SwapEntityGroup <EnemyEntityDescriptor>(enemyEntitiesViews[index].ID,
                                                                             ECSGroups.DeadEnemiesGroups);
                }

                yield return(null);
            }
        }
Пример #11
0
 public void Add(ref EntityStruct entityView, EGID egid)
 {
     _entityFunctions.SwapEntityGroup <SimpleEntityDescriptor>(entityView.ID, ExclusiveGroups.group1);
 }
Пример #12
0
 void SwapMinNeededForException(IEntityFunctions entityFunctions)
 {
     entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(18, group1, group2);
     entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(19, group1, group2);
     entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(20, group1, group2);
     entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(21, group1, group2);
     entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(22, group1, group2);
     entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(17, group1, group2);
     entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(16, group1, group2);
     entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(15, group1, group2);
     entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(14, group1, group2);
     entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(13, group1, group2);
     entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(11, group1, group2);
     entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(9, group1, group2);
     entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(6, group1, group2);
     entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(5, group1, group2);
     entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4, group1, group2);
     entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(3, group1, group2);
     entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(2, group1, group2);
     entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(0, group1, group2);
     entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(24, group1, group2);
     entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(25, group1, group2);
     entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(26, group1, group2);
     entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(27, group1, group2);
     entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(28, group1, group2);
     entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(23, group1, group2);
     entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(8, group1, group2);
     entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(7, group1, group2);
     entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(1, group1, group2);
     entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(12, group1, group2);
     entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(10, group1, group2);
 }
Пример #13
0
        public void TestMegaEntitySwap2()
        {
            unchecked
            {
                _entityFactory.BuildEntity <TestDescriptorEntityView>(new EGID(5000, group1), new[] { new TestIt(2) });
                _entityFactory.BuildEntity <TestDescriptorEntityView>(new EGID(4999, group1), new[] { new TestIt(2) });
                _entityFactory.BuildEntity <TestDescriptorEntityView>(new EGID(4998, group1), new[] { new TestIt(2) });
                _entityFactory.BuildEntity <TestDescriptorEntityView>(new EGID(4997, group1), new[] { new TestIt(2) });

                _entityFactory.BuildEntity <TestDescriptorEntityView>(new EGID(4996, group2), new[] { new TestIt(2) });
                _entityFactory.BuildEntity <TestDescriptorEntityView>(new EGID(4995, group2), new[] { new TestIt(2) });

                _entityFactory.BuildEntity <TestDescriptorEntityView>(new EGID(4994, group1), new[] { new TestIt(2) });
                _entityFactory.BuildEntity <TestDescriptorEntityView>(new EGID(4993, group1), new[] { new TestIt(2) });
                _entityFactory.BuildEntity <TestDescriptorEntityView>(new EGID(4992, group1), new[] { new TestIt(2) });

                _entityFactory.BuildEntity <TestDescriptorEntityView>(new EGID(4991, group2), new[] { new TestIt(2) });

                _entityFactory.BuildEntity <TestDescriptorEntityView>(new EGID(4990, group1), new[] { new TestIt(2) });
                _entityFactory.BuildEntity <TestDescriptorEntityView>(new EGID(4988, group1), new[] { new TestIt(2) });

                _entityFactory.BuildEntity <TestDescriptorEntityView>(new EGID(4987, group2), new[] { new TestIt(2) });
                _entityFactory.BuildEntity <TestDescriptorEntityView>(new EGID(4986, group2), new[] { new TestIt(2) });

                _entityFactory.BuildEntity <TestDescriptorEntityView>(new EGID(4985, group1), new[] { new TestIt(2) });

                _entityFactory.BuildEntity <TestDescriptorEntityView>(new EGID(4984, group2), new[] { new TestIt(2) });
                _entityFactory.BuildEntity <TestDescriptorEntityView>(new EGID(4980, group2), new[] { new TestIt(2) });

                _entityFactory.BuildEntity <TestDescriptorEntityView>(new EGID(4977, group2), new[] { new TestIt(2) });

                _entityFactory.BuildEntity <TestDescriptorEntityView>(new EGID(4976, group1), new[] { new TestIt(2) });

                _entityFactory.BuildEntity <TestDescriptorEntityView>(new EGID(4974, group2), new[] { new TestIt(2) });

                _entityFactory.BuildEntity <TestDescriptorEntityView>(new EGID(4971, group1), new[] { new TestIt(2) });
                _entityFactory.BuildEntity <TestDescriptorEntityView>(new EGID(4970, group1), new[] { new TestIt(2) });

                _entityFactory.BuildEntity <TestDescriptorEntityView>(new EGID(4967, group1), new[] { new TestIt(2) });
                _entityFactory.BuildEntity <TestDescriptorEntityView>(new EGID(4966, group1), new[] { new TestIt(2) });
                _entityFactory.BuildEntity <TestDescriptorEntityView>(new EGID(4965, group1), new[] { new TestIt(2) });
                _entityFactory.BuildEntity <TestDescriptorEntityView>(new EGID(4964, group1), new[] { new TestIt(2) });
                _entityFactory.BuildEntity <TestDescriptorEntityView>(new EGID(4963, group1), new[] { new TestIt(2) });
                _entityFactory.BuildEntity <TestDescriptorEntityView>(new EGID(4962, group1), new[] { new TestIt(2) });
                _entityFactory.BuildEntity <TestDescriptorEntityView>(new EGID(4961, group1), new[] { new TestIt(2) });
                _entityFactory.BuildEntity <TestDescriptorEntityView>(new EGID(4960, group1), new[] { new TestIt(2) });
                _entityFactory.BuildEntity <TestDescriptorEntityView>(new EGID(4959, group1), new[] { new TestIt(2) });
                _entityFactory.BuildEntity <TestDescriptorEntityView>(new EGID(4958, group1), new[] { new TestIt(2) });
                _entityFactory.BuildEntity <TestDescriptorEntityView>(new EGID(4957, group1), new[] { new TestIt(2) });

                _entityFactory.BuildEntity <TestDescriptorEntityView>(new EGID(4955, group1), new[] { new TestIt(2) });
                _entityFactory.BuildEntity <TestDescriptorEntityView>(new EGID(4954, group1), new[] { new TestIt(2) });
                _entityFactory.BuildEntity <TestDescriptorEntityView>(new EGID(4953, group1), new[] { new TestIt(2) });

                _simpleSubmissionEntityViewScheduler.SubmitEntities();

                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4996, group2, group1);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4995, group2, group1);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4991, group2, group1);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4986, group2, group1);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4984, group2, group1);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4980, group2, group1);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4977, group2, group1);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4974, group2, group1);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(5000, group1, group6);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4999, group1, group6);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4998, group1, group6);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4997, group1, group6);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4994, group1, group6);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4993, group1, group6);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4992, group1, group6);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4990, group1, group6);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4988, group1, group6);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4985, group1, group6);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4976, group1, group6);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4971, group1, group6);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4970, group1, group6);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4967, group1, group6);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4966, group1, group6);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4965, group1, group6);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4964, group1, group6);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4963, group1, group6);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4962, group1, group6);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4961, group1, group6);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4960, group1, group6);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4959, group1, group6);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4958, group1, group6);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4957, group1, group6);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4955, group1, group6);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4954, group1, group6);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4953, group1, group6);

                _simpleSubmissionEntityViewScheduler.SubmitEntities();

                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4974, group1, group6);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4977, group1, group6);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4980, group1, group6);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4984, group1, group6);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4986, group1, group6);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4991, group1, group6);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4995, group1, group6);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4996, group1, group6);
                _simpleSubmissionEntityViewScheduler.SubmitEntities();
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(5000, group6, group7);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4999, group6, group7);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4998, group6, group7);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4997, group6, group7);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4994, group6, group7);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4993, group6, group7);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4992, group6, group7);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4990, group6, group7);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4988, group6, group7);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4985, group6, group7);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4976, group6, group7);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4971, group6, group7);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4970, group6, group7);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4967, group6, group7);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4966, group6, group7);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4965, group6, group7);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4964, group6, group7);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4963, group6, group7);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4962, group6, group7);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4961, group6, group7);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4960, group6, group7);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4959, group6, group7);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4958, group6, group7);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4957, group6, group7);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4955, group6, group7);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4954, group6, group7);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4953, group6, group7);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4996, group6, group7);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4995, group6, group7);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4991, group6, group7);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4986, group6, group7);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4984, group6, group7);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4980, group6, group7);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4977, group6, group7);
                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4974, group6, group7);

                _simpleSubmissionEntityViewScheduler.SubmitEntities();

                EGID egid   = new EGID(4958, group7);
                bool exists =
                    ((IUnitTestingInterface)_enginesRoot).entitiesForTesting.Exists <TestEntityViewComponent>(egid);
                Assert.IsTrue(exists);

                _entityFunctions.SwapEntityGroup <TestDescriptorEntityView>(4961, group7, group8);
                _simpleSubmissionEntityViewScheduler.SubmitEntities();

                exists = ((IUnitTestingInterface)_enginesRoot).entitiesForTesting.Exists <TestEntityViewComponent>(egid);

                Assert.IsTrue(exists);
            }
        }