public void AttributesTestsMethod()
{
EntityWorld world = new EntityWorld();
world.PoolCleanupDelay = 1;
world.InitializeAll();
Debug.Assert(world.SystemManager.Systems.Size == 2);
Entity et = world.CreateEntity();
var power = et.AddComponentFromPool<Power2>();
power.POWER = 100;
et.Refresh();
Entity et1 = world.CreateEntityFromTemplate("teste");
Debug.Assert(et1 != null);
{
world.Update(0, ExecutionType.UpdateSynchronous);
}
et.RemoveComponent<Power2>();
et.Refresh();
{
world.Update(0, ExecutionType.UpdateSynchronous);
}
et.AddComponentFromPool<Power2>();
et.GetComponent<Power2>().POWER = 100;
et.Refresh();
world.Update(0, ExecutionType.UpdateSynchronous);
}
public void Start()
{
GameWindow.Window = new RenderWindow(new VideoMode(1280, 720), "Subject2Change");
GameWindow.Window.SetFramerateLimit(120);
GameWindow.Window.SetVisible(true);
GameWindow.Window.Closed += OnClosed;
GameWindow.Window.KeyPressed += GameEventHandler.OnKeyPressed;
GameWindow.Window.Resized += GameEventHandler.OnResized;
GameWindow.Window.KeyReleased += GameEventHandler.OnKeyReleased;
_world = new EntityWorld(false, true, true);
//Entity camera = _world.CreateEntityFromTemplate("camera");
EntityFactory.CreatePlayer(_world);
Sprite testSprite = SFMLwrap.LoadSprite("test.png", SFMLwrap.DefaultScale);
while (GameWindow.Window.IsOpen())
{
GameWindow.Window.DispatchEvents();
GameWindow.Window.Clear(Color.Blue);
testSprite.Position = EntityFactory.Player.GetComponent<TransformC>().Position;
_world.Update();
//SpriteBatch batch = new SpriteBatch(GameWindow.Window);
GameWindow.Window.Draw(testSprite);
GameWindow.Window.Display();
}
}
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 TestAttributes()
{
Debug.WriteLine("Initialize EntityWorld: ");
EntityWorld entityWorld = new EntityWorld { PoolCleanupDelay = 1 };
#if (!FULLDOTNET && !METRO) || CLIENTPROFILE
entityWorld.InitializeAll(global::System.Reflection.Assembly.GetExecutingAssembly());
#else
entityWorld.InitializeAll(true);
#endif
Debug.WriteLine("OK");
const int ExpectedNumberOfSystems = 2;
int actualNumberOfSystems = entityWorld.SystemManager.Systems.Count;
Assert.AreEqual(ExpectedNumberOfSystems, actualNumberOfSystems, "Number of initial systems does not fit.");
Debug.WriteLine("Number of Systems: {0} OK", actualNumberOfSystems);
Debug.WriteLine("Build up entity with component from pool manually: ");
Entity entityWithPooledComponent = TestEntityFactory.CreateTestPowerEntityWithPooledComponent(entityWorld);
Debug.WriteLine("OK");
Debug.WriteLine("Build up entity from template: ");
Entity entityFromTemplate = entityWorld.CreateEntityFromTemplate("test");
Assert.IsNotNull(entityFromTemplate, "Entity from test template is null.");
Debug.WriteLine("OK");
entityWorld.Update();
entityWorld.Draw();
Debug.WriteLine("Remove component from entity: ");
entityWithPooledComponent.RemoveComponent<TestPowerComponentPoolable>();
entityWorld.Update();
entityWorld.Draw();
Assert.IsFalse(entityWithPooledComponent.HasComponent<TestPowerComponentPoolable>(), "Entity has still deleted component.");
Debug.WriteLine("OK");
Debug.WriteLine("Add component to entity: ");
entityWithPooledComponent.AddComponentFromPool<TestPowerComponentPoolable>();
entityWithPooledComponent.GetComponent<TestPowerComponentPoolable>().Power = 100;
entityWorld.Update();
entityWorld.Draw();
Assert.IsTrue(entityWithPooledComponent.HasComponent<TestPowerComponentPoolable>(), "Could not add component to entity.");
Debug.WriteLine("OK");
}
public void TestUniqId()
{
global::System.Diagnostics.Debug.WriteLine("Initialize EntityWorld: ");
EntityWorld entityWorld = new EntityWorld();
entityWorld.SystemManager.SetSystem(new TestCommunicationSystem(), GameLoopType.Update);
#if !FULLDOTNET && !METRO
entityWorld.InitializeAll();
#else
entityWorld.InitializeAll(false);
#endif
global::System.Diagnostics.Debug.WriteLine("OK");
var ent1 = TestEntityFactory.CreateTestHealthEntityWithID(entityWorld, -5);
global::System.Diagnostics.Debug.WriteLine("ID1 " + ent1.UniqueId );
Debug.Assert(ent1.UniqueId == -5, "Ids dont match");
var ent2 = TestEntityFactory.CreateTestHealthEntity(entityWorld);
global::System.Diagnostics.Debug.WriteLine("ID2 " + ent2.UniqueId);
Debug.Assert(ent2.UniqueId != -5 && ent2.UniqueId > 0, "Ids cant match");
var entrec = entityWorld.EntityManager.GetEntityByUniqueID(-5);
Debug.Assert(ent1 == entrec, "Entities must match");
entrec = entityWorld.EntityManager.GetEntity(ent1.Id);
Debug.Assert(ent1 == entrec, "Entities must match");
entityWorld.DeleteEntity(ent1);
entityWorld.Update();
entrec = entityWorld.EntityManager.GetEntityByUniqueID(-5);
Debug.Assert(entrec==null, "Entity must be null");
entrec = entityWorld.EntityManager.GetEntity(ent1.Id);
Debug.Assert(entrec == null, "Entity must be null");
global::System.Diagnostics.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 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 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 SystemComunicationTeste()
{
EntitySystem.BlackBoard.SetEntry<int>("Damage", 5);
EntityWorld world = new EntityWorld();
SystemManager systemManager = world.SystemManager;
DummyCommunicationSystem DummyCommunicationSystem = new DummyCommunicationSystem();
systemManager.SetSystem(DummyCommunicationSystem, ExecutionType.UpdateSynchronous);
world.InitializeAll(false);
List<Entity> l = new List<Entity>();
for (int i = 0; i < 100; i++)
{
Entity et = world.CreateEntity();
et.AddComponent(new Health());
et.GetComponent<Health>().HP += 100;
et.Refresh();
l.Add(et);
}
{
DateTime dt = DateTime.Now;
world.Update(0);
Console.WriteLine((DateTime.Now - dt).TotalMilliseconds);
}
EntitySystem.BlackBoard.SetEntry<int>("Damage", 10);
{
DateTime dt = DateTime.Now;
world.Update(0);
Console.WriteLine((DateTime.Now - dt).TotalMilliseconds);
}
foreach (var item in l)
{
Debug.Assert(item.GetComponent<Health>().HP == 85);
}
}
public void SecondMostSimpleSystemEverTest()
{
EntityWorld world = new EntityWorld();
world.InitializeAll(true);
Entity et = world.CreateEntity();
et.AddComponent(new Health());
et.GetComponent<Health>().HP = 100;
et.Refresh();
Entity et1 = world.CreateEntity();
et1.AddComponent(new Power());
et1.GetComponent<Power>().POWER = 100;
et1.Refresh();
{
world.Update(0);
}
///two systems runnning
///each remove 10 HP
Debug.Assert(et.GetComponent<Health>().HP == 80);
Debug.Assert(et1.GetComponent<Power>().POWER == 90);
}
public void QueueSystemTeste()
{
EntityWorld world = new EntityWorld();
SystemManager systemManager = world.SystemManager;
QueueSystemTest QueueSystemTest = new ArtemisTest.QueueSystemTest();
QueueSystemTest QueueSystemTest2 = new ArtemisTest.QueueSystemTest();
systemManager.SetSystem(QueueSystemTest, ExecutionType.UpdateAsynchronous);
systemManager.SetSystem(QueueSystemTest2, ExecutionType.UpdateAsynchronous);
QueueSystemTest2 QueueSystemTestteste = new ArtemisTest.QueueSystemTest2();
systemManager.SetSystem(QueueSystemTestteste, ExecutionType.UpdateAsynchronous);
world.InitializeAll(false);
QueueSystemTest.SetQueueProcessingLimit(20, QueueSystemTest.Id);
Debug.Assert(QueueSystemTest.GetQueueProcessingLimit(QueueSystemTest.Id) == QueueSystemTest.GetQueueProcessingLimit(QueueSystemTest2.Id));
Debug.Assert(QueueSystemTest.GetQueueProcessingLimit(QueueSystemTestteste.Id) != QueueSystemTest.GetQueueProcessingLimit(QueueSystemTest2.Id));
QueueSystemTest.SetQueueProcessingLimit(1000, QueueSystemTest.Id);
QueueSystemTest.SetQueueProcessingLimit(2000, QueueSystemTestteste.Id);
List<Entity> l = new List<Entity>();
for (int i = 0; i < 1000000; i++)
{
Entity et = world.CreateEntity();
et.AddComponent(new Health());
et.GetComponent<Health>().HP = 100;
QueueSystemTest.AddToQueue(et, QueueSystemTest.Id);
l.Add(et);
}
List<Entity> l2 = new List<Entity>();
for (int i = 0; i < 1000000; i++)
{
Entity et = world.CreateEntity();
et.AddComponent(new Health());
et.GetComponent<Health>().HP = 100;
QueueSystemTest.AddToQueue(et, QueueSystemTestteste.Id);
l2.Add(et);
}
Console.WriteLine("Start");
while (QueueSystemTest.QueueCount(QueueSystemTest.Id) > 0 || QueueSystemTest.QueueCount(QueueSystemTestteste.Id) > 0)
{
DateTime dt = DateTime.Now;
world.Update(0, ExecutionType.UpdateAsynchronous);
Console.WriteLine("Count: " + QueueSystemTest.QueueCount(QueueSystemTest.Id));
Console.WriteLine("Time: " + (DateTime.Now - dt).TotalMilliseconds);
}
Console.WriteLine("End");
foreach (var item in l)
{
Debug.Assert(item.GetComponent<Health>().HP == 90);
}
foreach (var item in l2)
{
Debug.Assert(item.GetComponent<Health>().HP == 80);
}
}
public void multsystem()
{
healthBag.Clear();
componentPool.Clear();
healthBag.Add(new Health());
healthBag.Add(new Health());
componentPool.Add(typeof(Health), healthBag);
EntityWorld world = new EntityWorld();
SystemManager systemManager = world.SystemManager;
world.EntityManager.RemovedComponentEvent += new RemovedComponentHandler(RemovedComponent);
world.EntityManager.RemovedEntityEvent += new RemovedEntityHandler(RemovedEntity);
EntitySystem hs = systemManager.SetSystem(new SingleHealthBarRenderSystem(),ExecutionType.UpdateAsynchronous);
hs = systemManager.SetSystem(new DummySystem(),ExecutionType.UpdateAsynchronous);
hs = systemManager.SetSystem(new DummySystem2(), ExecutionType.UpdateAsynchronous);
hs = systemManager.SetSystem(new DummySystem3(), ExecutionType.UpdateAsynchronous);
world.InitializeAll(false);
List<Entity> l = new List<Entity>();
for (int i = 0; i < 100000; i++)
{
Entity et = world.CreateEntity();
et.AddComponent(new Health());
et.GetComponent<Health>().HP += 100;
et.Refresh();
l.Add(et);
}
for (int i = 0; i < 100; i++)
{
DateTime dt = DateTime.Now;
world.Update(0,ExecutionType.UpdateAsynchronous);
//systemManager.UpdateSynchronous(ExecutionType.Update);
Console.WriteLine((DateTime.Now - dt).TotalMilliseconds);
}
//int df = 0;
//foreach (var item in l)
//{
// if (item.GetComponent<Health>().GetHealth() == 90)
// {
// df++;
// }
// else
// {
// Console.WriteLine("errro");
// }
//}
}
public void multi()
{
healthBag.Add(new Health());
healthBag.Add(new Health());
componentPool.Add(typeof(Health), healthBag);
EntityWorld world = new EntityWorld();
SystemManager systemManager = world.SystemManager;
world.EntityManager.RemovedComponentEvent += new RemovedComponentHandler(RemovedComponent);
world.EntityManager.RemovedEntityEvent += new RemovedEntityHandler(RemovedEntity);
EntitySystem hs = systemManager.SetSystem(new MultHealthBarRenderSystem(), ExecutionType.UpdateSynchronous);
world.InitializeAll(false);
List<Entity> l = new List<Entity>();
for (int i = 0; i < 1000; i++)
{
Entity et = world.CreateEntity();
et.AddComponent(new Health());
et.GetComponent<Health>().HP += 100;
et.Refresh();
l.Add(et);
}
for (int i = 0; i < 100; i++)
{
DateTime dt = DateTime.Now;
world.Update(0);
Console.WriteLine((DateTime.Now - dt).TotalMilliseconds);
}
int df = 0;
foreach (var item in l)
{
if (item.GetComponent<Health>().HP == 90)
{
df++;
}
}
}
public void MostSimpleSystemEverTest()
{
EntityWorld world = new EntityWorld();
SystemManager systemManager = world.SystemManager;
MostSimpleSystemEver DummyCommunicationSystem = new MostSimpleSystemEver();
systemManager.SetSystem(DummyCommunicationSystem, ExecutionType.UpdateSynchronous);
world.InitializeAll(false);
Entity et = world.CreateEntity();
et.AddComponent(new Health());
et.GetComponent<Health>().HP = 100;
et.Refresh();
Entity et1 = world.CreateEntity();
et1.AddComponent(new Health());
et1.AddComponent(new Power());
et1.GetComponent<Health>().HP = 100;
et1.GetComponent<Power>().POWER = 100;
et1.Refresh();
{
DateTime dt = DateTime.Now;
world.Update(0);
Console.WriteLine((DateTime.Now - dt).TotalMilliseconds);
}
Debug.Assert(et.GetComponent<Health>().HP == 90);
Debug.Assert(et1.GetComponent<Health>().HP == 100);
Debug.Assert(et1.GetComponent<Power>().POWER == 100);
}
public void TestEntityComponentSystem()
{
EntityWorld entityWorld = new EntityWorld();
entityWorld.SystemManager.SetSystem(new TestEntityComponentProcessingSystem1(), GameLoopType.Update);
entityWorld.SystemManager.SetSystem(new TestEntityComponentProcessingSystem2(), GameLoopType.Update);
entityWorld.Update();
}
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 DummyTests()
{
EntityWorld world = new EntityWorld();
SystemManager systemManager = world.SystemManager;
DummyCommunicationSystem DummyCommunicationSystem = new DummyCommunicationSystem();
systemManager.SetSystem(DummyCommunicationSystem, ExecutionType.UpdateSynchronous);
world.InitializeAll(false);
for (int i = 0; i < 100; i++)
{
Entity et = world.CreateEntity();
et.AddComponent(new Health());
et.GetComponent<Health>().HP += 100;
et.Group = "teste";
et.Refresh();
}
{
Entity et = world.CreateEntity();
et.Tag = "tag";
et.AddComponent(new Health());
et.GetComponent<Health>().HP += 100;
et.Refresh();
}
{
DateTime dt = DateTime.Now;
world.Update(0);
Console.WriteLine((DateTime.Now - dt).TotalMilliseconds);
}
Debug.Assert(world.TagManager.GetEntity("tag") != null);
Debug.Assert(world.GroupManager.GetEntities("teste").Size == 100);
Debug.Assert(world.EntityManager.ActiveEntitiesCount == 101);
Debug.Assert(world.SystemManager.Systems.Size == 1);
}
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 HybridQueueSystemTeste()
{
EntityWorld world = new EntityWorld();
SystemManager systemManager = world.SystemManager;
HybridQueueSystemTest HybridQueueSystemTest = new ArtemisTest.HybridQueueSystemTest();
EntitySystem hs = systemManager.SetSystem(HybridQueueSystemTest, ExecutionType.UpdateSynchronous);
world.InitializeAll(false);
List<Entity> l = new List<Entity>();
for (int i = 0; i < 100; i++)
{
Entity et = world.CreateEntity();
et.AddComponent(new Health());
et.GetComponent<Health>().HP += 100;
et.Refresh();
l.Add(et);
}
for (int i = 0; i < 100; i++)
{
Entity et = world.CreateEntity();
et.AddComponent(new Health());
et.GetComponent<Health>().HP += 100;
HybridQueueSystemTest.
AddToQueue(et);
l.Add(et);
}
int j = 0;
while (HybridQueueSystemTest.QueueCount > 0)
{
j++;
DateTime dt = DateTime.Now;
world.Update(0);
Console.WriteLine((DateTime.Now - dt).TotalMilliseconds);
}
for (int i = 0; i < 100; i++)
{
Debug.Assert(l[i].GetComponent<Health>().HP == 100 - (10 * j));
}
for (int i = 100; i < 200; i++)
{
Debug.Assert(l[i].GetComponent<Health>().HP == 90);
}
}
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 TestPoolableComponents()
{
var entityWorld = new EntityWorld(isSortedEntities: false, processAttributes: true, initializeAll: true) { PoolCleanupDelay = 0 };
var pool = (ComponentPool<ComponentPoolable>)entityWorld.GetPool(typeof(TestPowerComponentPoolable));
Debug.WriteLine("ComponentPool<TestPowerComponentPoolable> is not Null:");
Assert.IsNotNull(pool);
Debug.WriteLine("OK");
var poolAttribute = (ArtemisComponentPool) typeof(TestPowerComponentPoolable).GetCustomAttributes(typeof(ArtemisComponentPool), false).Single();
Assert.AreEqual(poolAttribute.InitialSize, pool.InvalidCount, "Initially component pool should contain only invalid items");
int expectedPower = default(int);
var addedComponentEventHandler = new AddedComponentHandler((e, c) =>
{
Debug.WriteLine("TestPowerComponentPoolable added: ");
Assert.AreEqual(typeof (TestPowerComponentPoolable), c.GetType());
Debug.WriteLine("OK");
Debug.WriteLine("TestPowerComponentPoolable.Power == {0}:", expectedPower);
Assert.AreEqual(expectedPower, ((TestPowerComponentPoolable) c).Power);
Debug.WriteLine("OK");
});
entityWorld.EntityManager.AddedComponentEvent += addedComponentEventHandler;
Entity entity = entityWorld.CreateEntity();
Debug.WriteLine("Adding FRESH uninitialized TestPowerComponentPoolable from pool (expected power = {0})", default(int));
TestPowerComponentPoolable testPowerComponent = entity.AddComponentFromPool<TestPowerComponentPoolable>();
Assert.AreEqual(expectedPower, testPowerComponent.Power);
Assert.AreEqual(expectedPower, entity.GetComponent<TestPowerComponentPoolable>().Power);
entity.RemoveComponent<TestPowerComponentPoolable>();
entityWorld.Update();
Assert.IsFalse(entity.HasComponent<TestPowerComponentPoolable>());
expectedPower = 100;
Debug.WriteLine("Adding initialized TestPowerComponentPoolable from pool (expected power = {0})", expectedPower);
entity.AddComponentFromPool<TestPowerComponentPoolable>(c => c.Power = expectedPower);
Assert.AreEqual(expectedPower, entity.GetComponent<TestPowerComponentPoolable>().Power);
entity.RemoveComponent<TestPowerComponentPoolable>();
entityWorld.Update();
Assert.IsFalse(entity.HasComponent<TestPowerComponentPoolable>());
entityWorld.EntityManager.AddedComponentEvent -= addedComponentEventHandler;
Debug.WriteLine("Causing ComponentPool<TestPowerComponentPoolable> to fill up to maximum capacity...");
var entities = new List<Entity>();
while (pool.InvalidCount > 0)
{
var ent = entityWorld.CreateEntity();
ent.AddComponentFromPool<TestPowerComponentPoolable>(c => c.Power = expectedPower);
entities.Add(ent);
}
foreach (var ent in entities)
{
ent.RemoveComponent<TestPowerComponentPoolable>();
}
Debug.WriteLine("Causing ComponentPool<TestPowerComponentPoolable> cleanup...");
entityWorld.Update();
Assert.AreEqual(poolAttribute.InitialSize, pool.InvalidCount, "Cleaned up component pool should contain only invalid items");
Debug.WriteLine("OK");
entityWorld.EntityManager.AddedComponentEvent += addedComponentEventHandler;
Debug.WriteLine("Adding USED uninitialized TestPowerComponentPoolable from pool (expected power = {0})", expectedPower);
testPowerComponent = entity.AddComponentFromPool<TestPowerComponentPoolable>();
Assert.AreEqual(expectedPower, testPowerComponent.Power);
Assert.AreEqual(expectedPower, entity.GetComponent<TestPowerComponentPoolable>().Power);
}
public void TestUniqueId()
{
Debug.WriteLine("Initialize EntityWorld: ");
EntityWorld entityWorld = new EntityWorld();
entityWorld.SystemManager.SetSystem(new TestCommunicationSystem(), GameLoopType.Update);
entityWorld.InitializeAll();
Debug.WriteLine("OK");
Entity ent1 = TestEntityFactory.CreateTestHealthEntityWithId(entityWorld, -5);
Debug.WriteLine("ID1 " + ent1.UniqueId);
Debug.Assert(ent1.UniqueId == -5, "Ids dont match");
Entity ent2 = TestEntityFactory.CreateTestHealthEntity(entityWorld);
Debug.WriteLine("ID2 " + ent2.UniqueId);
Debug.Assert(ent2.UniqueId != -5 && ent2.UniqueId > 0, "Ids cant match");
Entity entrec = entityWorld.EntityManager.GetEntityByUniqueId(-5);
Debug.Assert(ent1 == entrec, "Entities must match");
entrec = entityWorld.EntityManager.GetEntity(ent1.Id);
Debug.Assert(ent1 == entrec, "Entities must match");
entityWorld.DeleteEntity(ent1);
entityWorld.Update();
entrec = entityWorld.EntityManager.GetEntityByUniqueId(-5);
Debug.Assert(entrec == null, "Entity must be null");
entrec = entityWorld.EntityManager.GetEntity(ent1.Id);
Debug.Assert(entrec == null, "Entity must be null");
Debug.WriteLine("OK");
}
public void TestRemoveComponent()
{
EntityWorld entityWorld = new EntityWorld();
Entity entity = entityWorld.CreateEntity();
// Remove absent component from a world with no components
entity.RemoveComponent<TestHealthComponent>();
Debug.WriteLine("OK");
entity.AddComponent(new TestHealthComponent());
entity.RemoveComponent<TestHealthComponent>();
// Removing component is deferred until the update
Assert.IsNotNull(entity.GetComponent<TestHealthComponent>());
// Update the world, component should be removed
entityWorld.Update();
Assert.IsNull(entity.GetComponent<TestHealthComponent>());
// Remove absent component
entity.RemoveComponent<TestHealthComponent>();
Debug.WriteLine("OK");
int defaultComponentsBagCapacity = 16;
for (int i = 0; i < defaultComponentsBagCapacity - 1; i++)
{
entity = entityWorld.CreateEntity();
entity.RemoveComponent<TestHealthComponent>();
}
Debug.WriteLine("OK");
entity = entityWorld.CreateEntity();
Assert.AreEqual(defaultComponentsBagCapacity, entity.Id, "Entity id has unexpected value.");
// Remove absent component now from Entity{16} (16 is the magic number = defaultComponentsBagCapacity)
entity.RemoveComponent<TestHealthComponent>();
Debug.WriteLine("OK");
}
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 TestAttributes()
{
Debug.WriteLine("Initialize EntityWorld: ");
EntityWorld entityWorld = new EntityWorld(false,true,true) { PoolCleanupDelay = 1 };
#if (!FULLDOTNET && !METRO) || CLIENTPROFILE
entityWorld.InitializeAll(global::System.Reflection.Assembly.GetExecutingAssembly());
#endif
Debug.WriteLine("OK");
const int ExpectedNumberOfSystems = 2;
int actualNumberOfSystems = entityWorld.SystemManager.Systems.Count;
Assert.AreEqual(ExpectedNumberOfSystems, actualNumberOfSystems, "Number of initial systems does not fit.");
Debug.WriteLine("Number of Systems: {0} OK", actualNumberOfSystems);
Debug.WriteLine("Build up entity with component from pool manually: ");
Entity entityWithPooledComponent = TestEntityFactory.CreateTestPowerEntityWithPooledComponent(entityWorld);
Debug.WriteLine("OK");
Debug.WriteLine("Build up entity from template: ");
Entity entityFromTemplate = entityWorld.CreateEntityFromTemplate("test");
Assert.IsNotNull(entityFromTemplate, "Entity from test template is null.");
Debug.WriteLine("OK");
entityWorld.Update();
entityWorld.Draw();
Debug.WriteLine("Remove component from entity: ");
entityWithPooledComponent.RemoveComponent<TestPowerComponentPoolable>();
entityWorld.Update();
entityWorld.Draw();
Assert.IsFalse(entityWithPooledComponent.HasComponent<TestPowerComponentPoolable>(), "Entity has still deleted component.");
Debug.WriteLine("OK");
Debug.WriteLine("Add component to entity: ");
entityWithPooledComponent.AddComponentFromPool<TestPowerComponentPoolable>();
entityWithPooledComponent.GetComponent<TestPowerComponentPoolable>().Power = 100;
entityWorld.Update();
entityWorld.Draw();
Assert.IsTrue(entityWithPooledComponent.HasComponent<TestPowerComponentPoolable>(), "Could not add component to entity.");
Debug.WriteLine("OK");
// TestNormalEntityProcessingSystem2 and TestNormalEntityProcessingSystem3 are autoloaded (marked with ArtemisEntitySystem attribute)
List<TestNormalEntityProcessingSystem2> listOfTestNormalEntityProcessingSystem2 = entityWorld.SystemManager.GetSystems<TestNormalEntityProcessingSystem2>();
Assert.IsNotNull(listOfTestNormalEntityProcessingSystem2, "Failed to retrieve autoloaded TestNormalEntityProcessingSystem2 system.");
Assert.AreEqual(1, listOfTestNormalEntityProcessingSystem2.Count, "Invalid count of TestNormalEntityProcessingSystem2 systems");
Debug.WriteLine("OK");
List<TestNormalEntityProcessingSystem3> listOfTestNormalEntityProcessingSystem3 = entityWorld.SystemManager.GetSystems<TestNormalEntityProcessingSystem3>();
Assert.IsNotNull(listOfTestNormalEntityProcessingSystem3, "Failed to retrieve autoloaded TestNormalEntityProcessingSystem3 system.");
Assert.AreEqual(1, listOfTestNormalEntityProcessingSystem3.Count, "Invalid count of TestNormalEntityProcessingSystem3 systems");
Debug.WriteLine("OK");
}