public void TestMultipleSystems()
{
Debug.WriteLine("Initialize EntityWorld: ");
HealthBag.Clear();
ComponentPool.Clear();
HealthBag.Add(new TestHealthComponent());
HealthBag.Add(new TestHealthComponent());
ComponentPool.Add(typeof(TestHealthComponent), HealthBag);
EntityWorld entityWorld = new EntityWorld();
entityWorld.EntityManager.RemovedComponentEvent += RemovedComponent;
entityWorld.EntityManager.RemovedEntityEvent += RemovedEntity;
entityWorld.SystemManager.SetSystem(new TestRenderHealthBarSingleSystem(), GameLoopType.Update);
entityWorld.SystemManager.SetSystem(new TestEntityProcessingSystem1(), GameLoopType.Update);
entityWorld.SystemManager.SetSystem(new TestEntityProcessingSystem2(), GameLoopType.Update);
entityWorld.SystemManager.SetSystem(new TestEntityProcessingSystem3(), GameLoopType.Update);
entityWorld.InitializeAll();
Debug.WriteLine("OK");
Debug.WriteLine("Fill EntityWorld with " + Load + " entities: ");
List <Entity> entities = new List <Entity>();
for (int index = Load - 1; index >= 0; --index)
{
Entity entity = TestEntityFactory.CreateTestHealthEntity(entityWorld);
entities.Add(entity);
}
Debug.WriteLine("OK");
const int Passes = 3;
Stopwatch stopwatch = Stopwatch.StartNew();
for (int index = 0; index < Passes; ++index)
{
entityWorld.Update();
entityWorld.Draw();
}
stopwatch.Stop();
Debug.WriteLine("Update (" + Passes + " passes) duration: {0}", FastDateTime.ToString(stopwatch.Elapsed));
/*
* int df = 0;
* foreach (Entity entity in entities)
* {
* if (Math.Abs(entity.GetComponent<TestHealthComponent>().Points - 90) < float.Epsilon)
* {
* df++;
* }
* else
* {
* Debug.WriteLine("Error " + df);
* }
* }
*/
}
public void TestDummies()
{
Debug.WriteLine("Initialize EntityWorld: ");
EntityWorld entityWorld = new EntityWorld();
entityWorld.SystemManager.SetSystem(new TestCommunicationSystem(), GameLoopType.Update);
entityWorld.InitializeAll();
Debug.WriteLine("OK");
Debug.WriteLine("Fill EntityWorld with " + Load + " grouped entities: ");
for (int index = Load - 1; index >= 0; --index)
{
TestEntityFactory.CreateTestHealthEntity(entityWorld, "test");
}
Debug.WriteLine("OK");
Debug.WriteLine("Add a tagged entity to EntityWorld: ");
TestEntityFactory.CreateTestHealthEntity(entityWorld, null, "tag");
Debug.WriteLine("OK");
Debug.WriteLine("Update EntityWorld: ");
Stopwatch stopwatch = Stopwatch.StartNew();
entityWorld.Update();
entityWorld.Draw();
stopwatch.Stop();
Debug.WriteLine("duration " + FastDateTime.ToString(stopwatch.Elapsed) + " ");
Debug.WriteLine("OK");
int actualNumberOfSystems = entityWorld.SystemManager.Systems.Count;
const int ExpectedNumberOfSystems = 1;
Debug.WriteLine("Number of Systems: {0} ", actualNumberOfSystems);
Assert.AreEqual(ExpectedNumberOfSystems, actualNumberOfSystems);
Debug.WriteLine("OK");
Entity actualTaggedEntity = entityWorld.TagManager.GetEntity("tag");
Debug.WriteLine("Is tagged entity present: {0} ", actualTaggedEntity != null);
Assert.IsNotNull(actualTaggedEntity);
Debug.WriteLine("OK");
int actualNumberOfGroupedEntities = entityWorld.GroupManager.GetEntities("test").Count;
const int ExpectedNumberOfGroupedEntities = Load;
Debug.WriteLine("Number of grouped entities: {0} ", actualNumberOfGroupedEntities);
Assert.AreEqual(ExpectedNumberOfGroupedEntities, actualNumberOfGroupedEntities);
Debug.WriteLine("OK");
#if DEBUG
int actualNumberOfActiveEntities = entityWorld.EntityManager.EntitiesRequestedCount;
const int ExpectedNumberOfActiveEntities = ExpectedNumberOfGroupedEntities + ExpectedNumberOfSystems;
Debug.WriteLine("Number of active entities: {0} ", actualNumberOfActiveEntities);
Assert.AreEqual(ExpectedNumberOfActiveEntities, actualNumberOfActiveEntities);
Debug.WriteLine("OK");
#endif
}
public void FTestQueueSystems()
{
Debug.WriteLine("Initialize EntityWorld: ");
EntityWorld entityWorld = new EntityWorld();
#if !PORTABLE
TestQueueSystemCopy2 testQueueSystem1 = entityWorld.SystemManager.SetSystem(new TestQueueSystemCopy2(10), GameLoopType.Update, 0, ExecutionType.Asynchronous);
#else
TestQueueSystemCopy2 testQueueSystem1 = entityWorld.SystemManager.SetSystem(new TestQueueSystemCopy2(10), GameLoopType.Update);
#endif
entityWorld.InitializeAll();
Debug.WriteLine("OK");
QueueSystemProcessingThreadSafe <DummyPlaceHolder> .SetQueueProcessingLimit(20, testQueueSystem1.Id);
Debug.WriteLine("Fill EntityWorld with first chunk of " + Load + " entities: ");
List <DummyPlaceHolder> entities1 = new List <DummyPlaceHolder>();
for (int index = Load; index >= 0; --index)
{
DummyPlaceHolder dph = new DummyPlaceHolder {
Component = new TestHealthComponent(100)
};
QueueSystemProcessingThreadSafe <DummyPlaceHolder> .AddToQueue(dph, testQueueSystem1.Id);
entities1.Add(dph);
}
Debug.WriteLine("OK");
Debug.WriteLine("Begin down tearing of queues...");
Stopwatch stopwatch = Stopwatch.StartNew();
int loopCount = 0;
while (QueueSystemProcessingThreadSafe <DummyPlaceHolder> .QueueCount(testQueueSystem1.Id) > 0 || QueueSystemProcessingThreadSafe <DummyPlaceHolder> .QueueCount(testQueueSystem1.Id) > 0)
{
entityWorld.Update();
entityWorld.Draw();
++loopCount;
#if DEBUG
Debug.WriteLine("Queue size thread A: {0} ", QueueSystemProcessingThreadSafe <DummyPlaceHolder> .QueueCount(testQueueSystem1.Id));
#endif
}
stopwatch.Stop();
Debug.WriteLine("End OK. Loops: {0} Time: {1}", loopCount, FastDateTime.ToString(stopwatch.Elapsed));
Debug.WriteLine("Test entities 1: ");
const float Expected1 = 90.0f;
foreach (DummyPlaceHolder entity in entities1)
{
TestHealthComponent testHealthComponent = entity.Component as TestHealthComponent;
if (testHealthComponent != null)
{
Assert.AreEqual(Expected1, testHealthComponent.Points);
}
}
Debug.WriteLine("OK");
}
public void TestRenderMultiHealthBarSystem()
{
Debug.WriteLine("Initialize EntityWorld: ");
HealthBag.Clear();
ComponentPool.Clear();
HealthBag.Add(new TestHealthComponent());
HealthBag.Add(new TestHealthComponent());
ComponentPool.Add(typeof(TestHealthComponent), HealthBag);
EntityWorld entityWorld = new EntityWorld();
entityWorld.EntityManager.RemovedComponentEvent += RemovedComponent;
entityWorld.EntityManager.RemovedEntityEvent += RemovedEntity;
entityWorld.SystemManager.SetSystem(new TestRenderHealthBarMultiSystem(), GameLoopType.Update);
entityWorld.InitializeAll();
Debug.WriteLine("OK");
Debug.WriteLine("Fill EntityWorld with " + Load + " entities: ");
List <Entity> entities = new List <Entity>();
for (int index = Load - 1; index >= 0; --index)
{
Entity entity = TestEntityFactory.CreateTestHealthEntity(entityWorld);
entities.Add(entity);
}
Debug.WriteLine("OK");
const int Passes = 9;
Stopwatch stopwatch = Stopwatch.StartNew();
for (int index = 0; index < Passes; ++index)
{
entityWorld.Update();
entityWorld.Draw();
}
stopwatch.Stop();
Debug.WriteLine("Update (" + Passes + " passes) duration: {0}", FastDateTime.ToString(stopwatch.Elapsed));
int expectedPoints = 100 - (Passes * 10);
if (expectedPoints < 0)
{
expectedPoints = 0;
}
int df = entities.Count(item => Math.Abs((int)(item.GetComponent <TestHealthComponent>().Points - expectedPoints)) < float.Epsilon);
Assert.AreEqual(Load, df);
Debug.WriteLine("Found {0} entities with health of {1}.", df, expectedPoints);
}
public void TestSystemCommunication()
{
Debug.WriteLine("Initialize EntityWorld: ");
EntitySystem.BlackBoard.SetEntry("Damage", 5);
EntityWorld entityWorld = new EntityWorld();
entityWorld.SystemManager.SetSystem(new TestCommunicationSystem(), GameLoopType.Update);
entityWorld.InitializeAll();
Debug.WriteLine("OK");
Debug.WriteLine("Fill EntityWorld with " + Load + " entities: ");
List <Entity> entities = new List <Entity>();
for (int index = Load; index >= 0; --index)
{
Entity entity = TestEntityFactory.CreateTestHealthEntity(entityWorld);
entities.Add(entity);
}
Debug.WriteLine("OK");
Stopwatch stopwatch = Stopwatch.StartNew();
entityWorld.Update();
entityWorld.Draw();
stopwatch.Stop();
Debug.WriteLine("Update 1 duration: {0}", FastDateTime.ToString(stopwatch.Elapsed));
EntitySystem.BlackBoard.SetEntry("Damage", 10);
stopwatch.Restart();
entityWorld.Update();
entityWorld.Draw();
stopwatch.Stop();
Debug.WriteLine("Update 2 duration: {0}", FastDateTime.ToString(stopwatch.Elapsed));
Debug.WriteLine("Test entities: ");
const float Expected = 85.0f;
foreach (Entity item in entities)
{
Assert.AreEqual(Expected, item.GetComponent <TestHealthComponent>().Points);
}
Debug.WriteLine("OK");
EntitySystem.BlackBoard.RemoveEntry("Damage");
}
public void TestQueueSystems()
{
Debug.WriteLine("Initialize EntityWorld: ");
EntityWorld entityWorld = new EntityWorld();
#if !PORTABLE
TestQueueSystem testQueueSystem1 = entityWorld.SystemManager.SetSystem(new TestQueueSystem(10), GameLoopType.Update, 0, ExecutionType.Asynchronous);
TestQueueSystem testQueueSystem2 = entityWorld.SystemManager.SetSystem(new TestQueueSystem(10), GameLoopType.Update, 0, ExecutionType.Asynchronous);
TestQueueSystemCopy testQueueSystem3 = entityWorld.SystemManager.SetSystem(new TestQueueSystemCopy(20), GameLoopType.Update, 0, ExecutionType.Asynchronous);
#else
TestQueueSystem testQueueSystem1 = entityWorld.SystemManager.SetSystem(new TestQueueSystem(10), GameLoopType.Update);
TestQueueSystem testQueueSystem2 = entityWorld.SystemManager.SetSystem(new TestQueueSystem(10), GameLoopType.Update);
TestQueueSystemCopy testQueueSystem3 = entityWorld.SystemManager.SetSystem(new TestQueueSystemCopy(20), GameLoopType.Update);
#endif
entityWorld.InitializeAll();
Debug.WriteLine("OK");
QueueSystemProcessingThreadSafe.SetQueueProcessingLimit(20, testQueueSystem2.Id);
int expectedLimit = QueueSystemProcessingThreadSafe.GetQueueProcessingLimit(testQueueSystem2.Id);
Assert.AreEqual(expectedLimit, QueueSystemProcessingThreadSafe.GetQueueProcessingLimit(testQueueSystem1.Id));
Assert.AreNotEqual(expectedLimit, QueueSystemProcessingThreadSafe.GetQueueProcessingLimit(testQueueSystem3.Id));
QueueSystemProcessingThreadSafe.SetQueueProcessingLimit(1024, testQueueSystem1.Id);
QueueSystemProcessingThreadSafe.SetQueueProcessingLimit(4096, testQueueSystem3.Id);
Debug.WriteLine("Fill EntityWorld with first chunk of " + Load + " entities: ");
List <Entity> entities1 = new List <Entity>();
for (int index = Load; index >= 0; --index)
{
Entity entity = TestEntityFactory.CreateTestHealthEntity(entityWorld);
QueueSystemProcessingThreadSafe.AddToQueue(entity, testQueueSystem1.Id);
entities1.Add(entity);
}
Debug.WriteLine("OK");
Debug.WriteLine("Fill EntityWorld with second chunk of " + Load + " entities: ");
List <Entity> entities2 = new List <Entity>();
for (int index = Load; index >= 0; --index)
{
Entity entity = TestEntityFactory.CreateTestHealthEntity(entityWorld);
QueueSystemProcessingThreadSafe.AddToQueue(entity, testQueueSystem3.Id);
entities2.Add(entity);
}
Debug.WriteLine("OK");
Debug.WriteLine("Begin down tearing of queues...");
Stopwatch stopwatch = Stopwatch.StartNew();
int loopCount = 0;
while (QueueSystemProcessingThreadSafe.QueueCount(testQueueSystem1.Id) > 0 || QueueSystemProcessingThreadSafe.QueueCount(testQueueSystem3.Id) > 0)
{
entityWorld.Update();
entityWorld.Draw();
++loopCount;
#if DEBUG
Debug.WriteLine("Queue size thread A: {0} B: {1}", QueueSystemProcessingThreadSafe.QueueCount(testQueueSystem1.Id), QueueSystemProcessingThreadSafe.QueueCount(testQueueSystem3.Id));
#endif
}
stopwatch.Stop();
Debug.WriteLine("End OK. Loops: {0} Time: {1}", loopCount, FastDateTime.ToString(stopwatch.Elapsed));
Debug.WriteLine("Test entities 1: ");
const float Expected1 = 90.0f;
foreach (Entity entity in entities1)
{
Assert.AreEqual(Expected1, entity.GetComponent <TestHealthComponent>().Points);
}
Debug.WriteLine("OK");
Debug.WriteLine("Test entities 2: ");
const float Expected2 = 80.0f;
foreach (Entity entity in entities2)
{
Assert.AreEqual(Expected2, entity.GetComponent <TestHealthComponent>().Points);
}
Debug.WriteLine("OK");
}
public void TestSimpleSystem2()
{
Debug.WriteLine("Initialize EntityWorld: ");
EntityWorld entityWorld = new EntityWorld();
TestEntityProcessingSystem testEntityProcessingSystem = entityWorld.SystemManager.SetSystem(new TestEntityProcessingSystem(), GameLoopType.Update);
entityWorld.InitializeAll();
Debug.WriteLine("OK");
const float Expected = 0;
Assert.AreEqual(Expected, testEntityProcessingSystem.Counter);
Stopwatch stopwatch = Stopwatch.StartNew();
entityWorld.Update();
entityWorld.Draw();
stopwatch.Stop();
#if DEBUG
Debug.WriteLine("Processed update and draw with duration {0} for {1} elements", FastDateTime.ToString(stopwatch.Elapsed), entityWorld.EntityManager.EntitiesRequestedCount);
#else
Debug.WriteLine("Processed update and draw with duration {0} for {1} elements", FastDateTime.ToString(stopwatch.Elapsed), entityWorld.EntityManager.ActiveEntities.Count);
#endif
const float Expected1 = 1;
Assert.AreEqual(Expected1, testEntityProcessingSystem.Counter);
Debug.WriteLine("OK");
}
public void TestSimpleSystem()
{
Debug.WriteLine("Initialize EntityWorld: ");
EntityWorld entityWorld = new EntityWorld();
entityWorld.SystemManager.SetSystem(new TestNormalEntityProcessingSystem1(), GameLoopType.Update);
entityWorld.InitializeAll();
Debug.WriteLine("OK");
Entity entity1 = TestEntityFactory.CreateTestHealthEntity(entityWorld);
Assert.IsNotNull(entity1);
Entity entity2 = TestEntityFactory.CreateTestPowerEntity(entityWorld);
Assert.IsNotNull(entity2);
Stopwatch stopwatch = Stopwatch.StartNew();
entityWorld.Update();
entityWorld.Draw();
stopwatch.Stop();
#if DEBUG
Debug.WriteLine("Processed update and draw with duration {0} for {1} elements", FastDateTime.ToString(stopwatch.Elapsed), entityWorld.EntityManager.EntitiesRequestedCount);
#else
Debug.WriteLine("Processed update and draw with duration {0} for {1} elements", FastDateTime.ToString(stopwatch.Elapsed), entityWorld.EntityManager.ActiveEntities.Count);
#endif
const float Expected1 = 90.0f;
Assert.AreEqual(Expected1, entity1.GetComponent <TestHealthComponent>().Points);
const float Expected2 = 100.0f;
Assert.AreEqual(Expected2, entity2.GetComponent <TestHealthComponent>().Points);
Assert.AreEqual(Expected2, entity2.GetComponent <TestPowerComponent>().Power);
}
public void TestHybridQueueSystem()
{
Debug.WriteLine("Initialize EntityWorld: ");
EntityWorld entityWorld = new EntityWorld();
TestQueueHybridSystem testQueueHybridSystem = entityWorld.SystemManager.SetSystem(new TestQueueHybridSystem(), GameLoopType.Update);
entityWorld.InitializeAll();
Debug.WriteLine("OK");
const int Chunk = 500;
Debug.WriteLine("Fill EntityWorld with first chunk of " + Chunk + " entities: ");
List <Entity> entities = new List <Entity>();
for (int index = Chunk; index > 0; --index)
{
entities.Add(TestEntityFactory.CreateTestHealthEntity(entityWorld));
}
Debug.WriteLine("OK");
Debug.WriteLine("Fill EntityWorld with second chunk of " + Chunk + " entities: ");
for (int index = Chunk; index > 0; --index)
{
Entity entity = TestEntityFactory.CreateTestHealthEntity(entityWorld);
testQueueHybridSystem.AddToQueue(entity);
entities.Add(entity);
}
Debug.WriteLine("OK");
Stopwatch stopwatch = Stopwatch.StartNew();
int numberOfQueues = 0;
while (testQueueHybridSystem.QueueCount > 0)
{
++numberOfQueues;
entityWorld.Update();
entityWorld.Draw();
}
stopwatch.Stop();
Debug.WriteLine("Processed {0} hybrid queues with duration {1}", numberOfQueues, FastDateTime.ToString(stopwatch.Elapsed));
Debug.WriteLine("Test first chunk: ");
float expectedPointsFirstChunk = 100.0f - (10 * numberOfQueues);
if (expectedPointsFirstChunk < 0.0f)
{
Debug.WriteLine("Results may be inaccurate. Please lower chunk size. ");
expectedPointsFirstChunk = 0.0f;
}
for (int index = Chunk - 1; index >= 0; --index)
{
Assert.AreEqual(expectedPointsFirstChunk, entities[index].GetComponent <TestHealthComponent>().Points, "Index:<" + index + ">.");
}
Debug.WriteLine("OK");
Debug.WriteLine("Test second chunk: ");
float expectedPointsSecondChunk = 90.0f - (10 * numberOfQueues);
if (expectedPointsSecondChunk < 0.0f)
{
Debug.WriteLine("Results may be inaccurate. Please lower chunk size. ");
expectedPointsSecondChunk = 0.0f;
}
for (int index = (Chunk * 2) - 1; index >= Chunk; --index)
{
Assert.AreEqual(expectedPointsSecondChunk, entities[index].GetComponent <TestHealthComponent>().Points, "Index:<" + index + ">.");
}
Debug.WriteLine("OK");
}
public void TestPerformance()
{
Debug.WriteLine("Number of elements: ");
// Identify max mem size.
Bag <int> bigBag = new Bag <int>();
#if METRO
int maxMem = 50;
#else
int maxMem = 5000;
#endif
// pointless to use int.maxvalue (sometimes it works, some it does not ... depends on other process)
for (int index = 0; index < maxMem; ++index)
{
try
{
bigBag.Add(index);
}
catch (Exception)
{
// some extra to be sure (there are some memory allocs we cant control in other threads)
maxMem = index;
break;
}
}
bigBag = null;
#if !MONO
// This is need to secure that enough memory is left.
GC.Collect();
GC.WaitForPendingFinalizers();
#if !METRO
GC.WaitForFullGCComplete();
#endif
GC.Collect();
#endif
Debug.WriteLine(maxMem.ToString(CultureInfo.InvariantCulture));
// Reset bag.
bigBag = new Bag <int>(0);
// Start measurement.
Stopwatch stopwatch = Stopwatch.StartNew();
// Fill
for (int index = maxMem; index >= 0; --index)
{
bigBag.Add(index);
}
stopwatch.Stop();
Debug.WriteLine("Load duration: {0}", FastDateTime.ToString(stopwatch.Elapsed));
stopwatch.Restart();
bigBag.Clear();
stopwatch.Stop();
Debug.WriteLine("Clear duration: {0}", FastDateTime.ToString(stopwatch.Elapsed));
}