Index: /code/branches/core/src/orxonox/Orxonox.cc
===================================================================
--- /code/branches/core/src/orxonox/Orxonox.cc	(revision 796)
+++ /code/branches/core/src/orxonox/Orxonox.cc	(revision 797)
@@ -76,4 +76,11 @@
 #include "GraphicsEngine.h"
 
+#include "objects/WorldEntity.h"
+#include "core/BaseObject.h"
+#include "objects/Test.h"
+#include "objects/test1.h"
+#include "objects/test2.h"
+#include "objects/test3.h"
+
 #include "Orxonox.h"
 
@@ -223,5 +230,528 @@
       break;
     }
-    startRenderLoop();
+
+        #define testandcout(code) \
+          std::cout << #code << " " << code << "\n"
+
+/*
+        std::cout << "Test 1\n";
+        BaseObject* test1;
+        test1 = new BaseObject();
+        test1 = new BaseObject();
+        test1 = new BaseObject();
+
+        std::cout << "Test 2\n";
+        A1* test2;
+        test2 = new A1();
+        test2 = new A1();
+        test2 = new A1();
+
+        std::cout << "Test 3\n";
+        BaseObject* test3;
+        test3 = new BaseObject();
+        test3 = new BaseObject();
+        test3 = new BaseObject();
+
+        std::cout << "Test 4\n";
+        A3* test4;
+        test4 = new A3();
+        test4 = new A3();
+        test4 = new A3();
+*/
+/*
+        std::cout << "Test 5\n";
+        A1* test5_01 = new A1();
+        A2* test5_02 = new A2();
+        A3* test5_03 = new A3();
+        A1B1* test5_04 = new A1B1();
+        A1B2* test5_05 = new A1B2();
+        A2B1* test5_06 = new A2B1();
+        A2B2* test5_07 = new A2B2();
+        A3B1* test5_08 = new A3B1();
+        A3B2* test5_09 = new A3B2();
+        A1B1C1* test5_10 = new A1B1C1();
+        A1B1C2* test5_11 = new A1B1C2();
+        A1B2C1* test5_12 = new A1B2C1();
+        A2B1C1* test5_13 = new A2B1C1();
+        A2B2C1* test5_14 = new A2B2C1();
+        A3B1C1* test5_15 = new A3B1C1();
+        A3B1C2* test5_16 = new A3B1C2();
+        A3B2C1* test5_17 = new A3B2C1();
+        A3B2C2* test5_18 = new A3B2C2();
+
+        OrxonoxClass* test5;
+        for (int i = 0; i <= 18; i++)
+        {
+          if (i == 0) test5 = new BaseObject;
+          if (i == 1) test5 = test5_01;
+          if (i == 2) test5 = test5_02;
+          if (i == 3) test5 = test5_03;
+          if (i == 4) test5 = test5_04;
+          if (i == 5) test5 = test5_05;
+          if (i == 6) test5 = test5_06;
+          if (i == 7) test5 = test5_07;
+          if (i == 8) test5 = test5_08;
+          if (i == 9) test5 = test5_09;
+          if (i == 10) test5 = test5_10;
+          if (i == 11) test5 = test5_11;
+          if (i == 12) test5 = test5_12;
+          if (i == 13) test5 = test5_13;
+          if (i == 14) test5 = test5_14;
+          if (i == 15) test5 = test5_15;
+          if (i == 16) test5 = test5_16;
+          if (i == 17) test5 = test5_17;
+          if (i == 18) test5 = test5_18;
+
+          std::cout << "\n";
+          std::cout << test5->getIdentifier()->getName() << " (" << test5->getIdentifier()->getNetworkID() << "): parents:     " << test5->getIdentifier()->getParents().toString() << "\n";
+          std::cout << test5->getIdentifier()->getName() << " (" << test5->getIdentifier()->getNetworkID() << "): children:    " << test5->getIdentifier()->getChildren().toString() << "\n";
+        }
+
+        std::cout << "Class with ID 0: " << ID(0) << " " << ID(0)->getName() << "\n";
+        std::cout << "Class with ID 1: " << ID(1) << " " << ID(1)->getName() << "\n";
+        std::cout << "Class with ID 2: " << ID(2) << " " << ID(2)->getName() << "\n";
+        std::cout << "Class with ID 3: " << ID(3) << " " << ID(3)->getName() << "\n";
+        std::cout << "Class with ID 4: " << ID(4) << " " << ID(4)->getName() << "\n";
+        std::cout << "Class with ID 100: " << ID(100) << "\n";
+        std::cout << "ID of BaseObject: " << Class(BaseObject)->getNetworkID() << "\n";
+
+        std::cout << "\nChange ID of BaseObject to 100\n";
+        Class(BaseObject)->setNetworkID(100);
+        std::cout << "Class with ID 100: " << ID(100) << "\n";
+        std::cout << "Class with ID 1: " << ID(1) << "\n";
+        std::cout << "ID of BaseObject: " << Class(BaseObject)->getNetworkID() << "\n";
+
+        std::cout << "\nChange ID of BaseObject to 3\n";
+        Class(BaseObject)->setNetworkID(3);
+        std::cout << "Class with ID 100: " << ID(100) << "\n";
+        std::cout << "Class with ID 1: " << ID(1) << "\n";
+        std::cout << "Class with ID 3: " << ID(3) << "\n";
+        std::cout << "ID of BaseObject: " << Class(BaseObject)->getNetworkID() << "\n";
+        std::cout << "ID of Test1: " << Class(Test1)->getNetworkID() << "\n";
+*/
+/*
+        std::cout << "\n";
+        std::cout << "isA(XYZ)-Test:\n";
+        std::cout << "test5_01 = A1, Erwartet: 1 0 0 1 0\n";
+        testandcout(test5_01->isA(Class(A1)));
+        testandcout(test5_01->isA(Class(A2)));
+        testandcout(test5_01->isA(Class(A1B1)));
+        testandcout(test5_01->isA(Class(BaseObject)));
+        testandcout(test5_01->isA(Class(Interface1)));
+
+        std::cout << "\n";
+        std::cout << "test5_02 = A2, Erwartet: 0 1 0 1 0\n";
+        testandcout(test5_02->isA(Class(A1)));
+        testandcout(test5_02->isA(Class(A2)));
+        testandcout(test5_02->isA(Class(A1B1)));
+        testandcout(test5_02->isA(Class(BaseObject)));
+        testandcout(test5_02->isA(Class(Interface1)));
+
+        std::cout << "\n";
+        std::cout << "test5_01 = A3, Erwartet: 0 0 0 1 1\n";
+        testandcout(test5_03->isA(Class(A1)));
+        testandcout(test5_03->isA(Class(A2)));
+        testandcout(test5_03->isA(Class(A1B1)));
+        testandcout(test5_03->isA(Class(BaseObject)));
+        testandcout(test5_03->isA(Class(Interface1)));
+
+        std::cout << "\n";
+        std::cout << "isDirectA(XYZ)-Test:\n";
+        std::cout << "test5_01 = A1, Erwartet: 1 0 0 0 0\n";
+        testandcout(test5_01->isDirectlyA(Class(A1)));
+        testandcout(test5_01->isDirectlyA(Class(A2)));
+        testandcout(test5_01->isDirectlyA(Class(A1B1)));
+        testandcout(test5_01->isDirectlyA(Class(BaseObject)));
+        testandcout(test5_01->isDirectlyA(Class(Interface1)));
+
+        std::cout << "\n";
+        std::cout << "test5_02 = A2, Erwartet: 0 1 0 0 0\n";
+        testandcout(test5_02->isDirectlyA(Class(A1)));
+        testandcout(test5_02->isDirectlyA(Class(A2)));
+        testandcout(test5_02->isDirectlyA(Class(A1B1)));
+        testandcout(test5_02->isDirectlyA(Class(BaseObject)));
+        testandcout(test5_02->isDirectlyA(Class(Interface1)));
+
+        std::cout << "\n";
+        std::cout << "test5_03 = A3, Erwartet: 0 0 0 0 0\n";
+        testandcout(test5_03->isDirectlyA(Class(A1)));
+        testandcout(test5_03->isDirectlyA(Class(A2)));
+        testandcout(test5_03->isDirectlyA(Class(A1B1)));
+        testandcout(test5_03->isDirectlyA(Class(BaseObject)));
+        testandcout(test5_03->isDirectlyA(Class(Interface1)));
+
+        std::cout << "\n";
+        std::cout << "isChildOf(XYZ)-Test:\n";
+        std::cout << "test5_04 = A1B1, Erwartet: 1 0 1 0 0 0 0\n";
+        testandcout(test5_04->isChildOf(Class(A1)));
+        testandcout(test5_04->isChildOf(Class(A2)));
+        testandcout(test5_04->isChildOf(Class(BaseObject)));
+        testandcout(test5_04->isChildOf(Class(Interface1)));
+        testandcout(test5_04->isChildOf(Class(Interface2)));
+        testandcout(test5_04->isChildOf(Class(A1B1C2)));
+        testandcout(test5_04->isChildOf(Class(A1B1)));
+
+        std::cout << "\n";
+        std::cout << "test5_06 = A2B1, Erwartet: 0 1 1 0 0 0 0\n";
+        testandcout(test5_06->isChildOf(Class(A1)));
+        testandcout(test5_06->isChildOf(Class(A2)));
+        testandcout(test5_06->isChildOf(Class(BaseObject)));
+        testandcout(test5_06->isChildOf(Class(Interface1)));
+        testandcout(test5_06->isChildOf(Class(Interface2)));
+        testandcout(test5_06->isChildOf(Class(A1B1C2)));
+        testandcout(test5_06->isChildOf(Class(A1B1)));
+
+        std::cout << "\n";
+        std::cout << "test5_07 = A2B2, Erwartet: 0 1 1 1 0 0\n";
+        testandcout(test5_07->isChildOf(Class(A1)));
+        testandcout(test5_07->isChildOf(Class(A2)));
+        testandcout(test5_07->isChildOf(Class(BaseObject)));
+        testandcout(test5_07->isChildOf(Class(Interface1)));
+        testandcout(test5_07->isChildOf(Class(Interface2)));
+        testandcout(test5_07->isChildOf(Class(A1B1C2)));
+
+        std::cout << "\n";
+        std::cout << "test5_08 = A3B1, Erwartet: 0 0 1 1 0 0\n";
+        testandcout(test5_08->isChildOf(Class(A1)));
+        testandcout(test5_08->isChildOf(Class(A2)));
+        testandcout(test5_08->isChildOf(Class(BaseObject)));
+        testandcout(test5_08->isChildOf(Class(Interface1)));
+        testandcout(test5_08->isChildOf(Class(Interface2)));
+        testandcout(test5_08->isChildOf(Class(A1B1C2)));
+
+        std::cout << "\n";
+        std::cout << "test5_09 = A3B2, Erwartet: 0 0 1 1 1 0\n";
+        testandcout(test5_09->isChildOf(Class(A1)));
+        testandcout(test5_09->isChildOf(Class(A2)));
+        testandcout(test5_09->isChildOf(Class(BaseObject)));
+        testandcout(test5_09->isChildOf(Class(Interface1)));
+        testandcout(test5_09->isChildOf(Class(Interface2)));
+        testandcout(test5_09->isChildOf(Class(A1B1C2)));
+
+        std::cout << "\n";
+        std::cout << "isParentOf(XYZ)-Test:\n";
+        std::cout << "test1 = BaseObject, Erwartet: 0 0 1 1 1 1 1\n";
+        testandcout(test1->isParentOf(Class(BaseObject)));
+        testandcout(test1->isParentOf(Class(Interface1)));
+        testandcout(test1->isParentOf(Class(A1)));
+        testandcout(test1->isParentOf(Class(A2)));
+        testandcout(test1->isParentOf(Class(A1B1)));
+        testandcout(test1->isParentOf(Class(A2B2)));
+        testandcout(test1->isParentOf(Class(A3B1C2)));
+
+        std::cout << "\n";
+        std::cout << "test5_01 = A1, Erwartet: 0 0 0 0 1 0 0\n";
+        testandcout(test5_01->isParentOf(Class(BaseObject)));
+        testandcout(test5_01->isParentOf(Class(Interface1)));
+        testandcout(test5_01->isParentOf(Class(A1)));
+        testandcout(test5_01->isParentOf(Class(A2)));
+        testandcout(test5_01->isParentOf(Class(A1B1)));
+        testandcout(test5_01->isParentOf(Class(A2B2)));
+        testandcout(test5_01->isParentOf(Class(A3B1C2)));
+
+        std::cout << "\n";
+        std::cout << "Interface1, Erwartet: 0 0 0 0 0 1 1\n";
+        testandcout(Class(Interface1)->isParentOf(Class(BaseObject)));
+        testandcout(Class(Interface1)->isParentOf(Class(Interface1)));
+        testandcout(Class(Interface1)->isParentOf(Class(A1)));
+        testandcout(Class(Interface1)->isParentOf(Class(A2)));
+        testandcout(Class(Interface1)->isParentOf(Class(A1B1)));
+        testandcout(Class(Interface1)->isParentOf(Class(A2B2)));
+        testandcout(Class(Interface1)->isParentOf(Class(A3B1C2)));
+*/
+/*
+        std::cout << "Test 6\n";
+        std::cout << "1:\n";
+        Identifier* test6_01 = Class(A1B1);
+        std::cout << "2:\n";
+        Identifier* test6_02 = Class(A1B1);
+        std::cout << "3:\n";
+        Identifier* test6_03 = Class(A1);
+        std::cout << "4:\n";
+        Identifier* test6_04 = Class(A1B1C1);
+        std::cout << "5:\n";
+        Identifier* test6_05 = Class(A1B1);
+        std::cout << "6:\n";
+        Identifier* test6_06 = Class(A1B1C1);
+
+        std::cout << "\n";
+        std::cout << "BaseObject: parents:     " << Class(BaseObject)->getParents().toString() << "\n";
+        std::cout << "BaseObject: children:    " << Class(BaseObject)->getChildren().toString() << "\n";
+
+        std::cout << "\n";
+        std::cout << "A1: parents:     " << Class(A1)->getParents().toString() << "\n";
+        std::cout << "A1: children:    " << Class(A1)->getChildren().toString() << "\n";
+
+        std::cout << "\n";
+        std::cout << "A1B1: parents:     " << Class(A1B1)->getParents().toString() << "\n";
+        std::cout << "A1B1: children:    " << Class(A1B1)->getChildren().toString() << "\n";
+
+        std::cout << "\n";
+        std::cout << "A1B1C1: parents:     " << Class(A1B1C1)->getParents().toString() << "\n";
+        std::cout << "A1B1C1: children:    " << Class(A1B1C1)->getChildren().toString() << "\n";
+
+        std::cout << "\n";
+        std::cout << "A3B1C1 child of A3:  " << Class(A3B1C1)->isChildOf(Class(A3)) << "\n";
+        std::cout << "\n";
+        std::cout << "A2 parent of A2B1C1: " << Class(A2)->isParentOf(Class(A2B1C1)) << "\n";
+*/
+/*
+        std::cout << "Test 7\n";
+        std::cout << "1\n";
+        SubclassIdentifier<A1B1> test7_01;
+        test7_01 = Class(A1B1C1);
+
+        SubclassIdentifier<A1B1> test7_02;
+        test7_02 = Class(A1B1);
+
+        std::cout << test7_01->getName() << "\n";
+        std::cout << test7_02->getName() << "\n";
+*/
+/*
+        std::cout << "2\n";
+
+        SubclassIdentifier<A1B1> test7_03;
+        test7_03 = Class(A1);
+
+        SubclassIdentifier<A1B1> test7_04;
+        test7_04 = Class(A1B2);
+
+        SubclassIdentifier<A1B1> test7_05;
+        test7_05 = Class(A2);
+*/
+/*
+        std::cout << "Test 8\n";
+
+        std::cout << "1\n";
+        Test1* test8_01 = new Test1;
+        Test3* test8_03 = new Test3;
+        test8_03->usefullClassesIsATest(test8_01);
+
+        std::cout << "2\n";
+        Test2* test8_02 = new Test2;
+        test8_03->usefullClassesIsATest(test8_02);
+
+        std::cout << "3\n";
+        test8_01->setUsefullClass1(Class(Test1));
+        test8_01->setUsefullClass1(test8_02->getIdentifier());
+        test8_01->setUsefullClass2(Class(Test2));
+        test8_01->setUsefullClassOfTypeTest3(Class(Test3));
+        test8_01->setUsefullClassOfTypeTest3(test8_03->getIdentifier());
+
+
+        testandcout(test8_01->isA(Class(Test1)));
+        testandcout(test8_01->isA(Class(Test2)));
+        testandcout(test8_01->isA(Class(Test3)));
+
+        Test2* test8_04 = new Test2;
+        testandcout(test8_02->isA(Class(Test1)));
+        testandcout(test8_02->isA(Class(Test2)));
+        testandcout(test8_02->isA(Class(Test3)));
+
+        Test3* test8_05 = new Test3;
+        testandcout(test8_03->isA(Class(Test1)));
+        testandcout(test8_03->isA(Class(Test2)));
+        testandcout(test8_03->isA(Class(Test3)));
+
+        delete test8_01;
+        delete test8_02;
+        delete test8_03;
+
+
+        std::cout << "Test 9\n";
+        std::cout << "1\n";
+        Identifier* test9_01 = Class(A3);
+        BaseObject* test9_02 = test9_01->fabricate();
+        std::cout << test9_02->getIdentifier()->getName() << "\n";
+
+        std::cout << "\n2\n";
+        BaseObject* test9_03 = Class(A1B2)->fabricate();
+        std::cout << test9_03->getIdentifier()->getName() << "\n";
+
+        std::cout << "\n3\n";
+        SubclassIdentifier<A1> test9_04;
+        test9_04 = Class(A1B1C1);
+        A1* test9_05 = test9_04.fabricate();
+        std::cout << test9_05->getIdentifier()->getName() << "\n";
+
+        std::cout << "\n4\n";
+        BaseObject* test9_06 = ID("A2B2")->fabricate();
+        std::cout << test9_06->getIdentifier()->getName() << "\n";
+
+        std::cout << "\n5\n";
+        delete test9_02;
+        delete test9_03;
+        delete test9_05;
+        delete test9_06;
+*/
+/*
+        std::cout << "Test 10\n";
+        Identifier* test10_01 = Class(A1B2);
+        Identifier* test10_02 = Class(A2);
+        Identifier* test10_03 = Class(A3B1C1);
+
+        BaseObject* test10_04 = test10_01->fabricate();
+        BaseObject* test10_05 = test10_02->fabricate();
+        BaseObject* test10_06 = test10_03->fabricate();
+
+        BaseObject* test10_07;
+        for (int i = 0; i < 10; i++)
+            test10_07 = ID("A1B1C1")->fabricate();
+
+        std::cout << "1\n";
+        int count;
+
+        count = 0; for (Iterator<BaseObject> it = ObjectList<BaseObject>::start(); it != 0; ++it) { count++; }
+        std::cout << "Anzahl BaseObjects: " << count << "\n";
+        count = 0; for (Iterator<A1> it = ObjectList<A1>::start(); it != 0; ++it) { count++; }
+        std::cout << "Anzahl A1: " << count << "\n";
+        count = 0; for (Iterator<A1B1> it = ObjectList<A1B1>::start(); it; ++it) { count++; }
+        std::cout << "Anzahl A1B1: " << count << "\n";
+        count = 0; for (Iterator<A1B1C1> it = ObjectList<A1B1C1>::start(); it; ++it) { count++; }
+        std::cout << "Anzahl A1B1C1: " << count << "\n";
+        count = 0; for (Iterator<A2> it = ObjectList<A2>::start(); it; ++it) { count++; }
+        std::cout << "Anzahl A2: " << count << "\n";
+
+        std::cout << "2\n";
+        BaseObject* test10_08;
+        BaseObject* test10_09;
+        BaseObject* test10_10;
+        for (int i = 0; i < 10; i++)
+        {
+            test10_08 = ID("A2B1C1")->fabricate();
+            std::string objName = "A2B1C1#";
+            objName += '0' + i;
+            test10_08->setName(objName);
+
+            if (i == 0)
+                test10_09 = test10_08;
+
+            if (i == 5)
+                test10_10 = test10_08;
+        }
+
+        count = 0; for (Iterator<BaseObject> it = ObjectList<BaseObject>::start(); it != 0; ++it) { count++; }
+        std::cout << "Anzahl BaseObjects: " << count << "\n";
+        count = 0; for (Iterator<A1> it = ObjectList<A1>::start(); it != 0; ++it) { count++; }
+        std::cout << "Anzahl A1: " << count << "\n";
+        count = 0; for (Iterator<A1B1> it = ObjectList<A1B1>::start(); it; ++it) { count++; }
+        std::cout << "Anzahl A1B1: " << count << "\n";
+        count = 0; for (Iterator<A1B1C1> it = ObjectList<A1B1C1>::start(); it; ++it) { count++; }
+        std::cout << "Anzahl A1B1C1: " << count << "\n";
+        count = 0; for (Iterator<A2> it = ObjectList<A2>::start(); it; ++it) { count++; }
+        std::cout << "Anzahl A2: " << count << "\n";
+
+        for (Iterator<A2B1C1> it = ObjectList<A2B1C1>::start(); it; ++it)
+            std::cout << "Name: " << it->getName() << "\n";
+
+        std::cout << "3\n";
+        for (Iterator<A2B1C1> it = ObjectList<A2B1C1>::end(); it; --it)
+            std::cout << "Name: " << it->getName() << "\n";
+
+        std::cout << "4\n";
+        delete test10_08;
+
+        count = 0; for (Iterator<BaseObject> it = ObjectList<BaseObject>::start(); it != 0; ++it) { count++; }
+        std::cout << "Anzahl BaseObjects: " << count << "\n";
+        count = 0; for (Iterator<A1> it = ObjectList<A1>::start(); it != 0; ++it) { count++; }
+        std::cout << "Anzahl A1: " << count << "\n";
+        count = 0; for (Iterator<A1B1> it = ObjectList<A1B1>::start(); it; ++it) { count++; }
+        std::cout << "Anzahl A1B1: " << count << "\n";
+        count = 0; for (Iterator<A1B1C1> it = ObjectList<A1B1C1>::start(); it; ++it) { count++; }
+        std::cout << "Anzahl A1B1C1: " << count << "\n";
+        count = 0; for (Iterator<A2> it = ObjectList<A2>::start(); it; ++it) { count++; }
+        std::cout << "Anzahl A2: " << count << "\n";
+
+        std::cout << "5\n";
+        for (Iterator<A2B1C1> it = ObjectList<A2B1C1>::start(); it; ++it)
+            std::cout << "Name: " << it->getName() << "\n";
+
+        std::cout << "6\n";
+        for (Iterator<A2B1C1> it = ObjectList<A2B1C1>::end(); it; --it)
+            std::cout << "Name: " << it->getName() << "\n";
+
+        std::cout << "7\n";
+        delete test10_09;
+
+        count = 0; for (Iterator<BaseObject> it = ObjectList<BaseObject>::end(); it != 0; --it) { count++; }
+        std::cout << "Anzahl BaseObjects: " << count << "\n";
+        count = 0; for (Iterator<A1> it = ObjectList<A1>::end(); it != 0; --it) { count++; }
+        std::cout << "Anzahl A1: " << count << "\n";
+        count = 0; for (Iterator<A1B1> it = ObjectList<A1B1>::end(); it; --it) { count++; }
+        std::cout << "Anzahl A1B1: " << count << "\n";
+        count = 0; for (Iterator<A1B1C1> it = ObjectList<A1B1C1>::end(); it; --it) { count++; }
+        std::cout << "Anzahl A1B1C1: " << count << "\n";
+        count = 0; for (Iterator<A2> it = ObjectList<A2>::end(); it; --it) { count++; }
+        std::cout << "Anzahl A2: " << count << "\n";
+
+        std::cout << "8\n";
+        for (Iterator<A2B1C1> it = ObjectList<A2B1C1>::start(); it; ++it)
+            std::cout << "Name: " << it->getName() << "\n";
+
+        std::cout << "9\n";
+        for (Iterator<A2B1C1> it = ObjectList<A2B1C1>::end(); it; --it)
+            std::cout << "Name: " << it->getName() << "\n";
+
+        std::cout << "10\n";
+        delete test10_10;
+
+        count = 0; for (Iterator<BaseObject> it = ObjectList<BaseObject>::start(); it != 0; ++it) { count++; }
+        std::cout << "Anzahl BaseObjects: " << count << "\n";
+        count = 0; for (Iterator<A1> it = ObjectList<A1>::start(); it != 0; ++it) { count++; }
+        std::cout << "Anzahl A1: " << count << "\n";
+        count = 0; for (Iterator<A1B1> it = ObjectList<A1B1>::start(); it; ++it) { count++; }
+        std::cout << "Anzahl A1B1: " << count << "\n";
+        count = 0; for (Iterator<A1B1C1> it = ObjectList<A1B1C1>::start(); it; ++it) { count++; }
+        std::cout << "Anzahl A1B1C1: " << count << "\n";
+        count = 0; for (Iterator<A2> it = ObjectList<A2>::start(); it; ++it) { count++; }
+        std::cout << "Anzahl A2: " << count << "\n";
+
+        std::cout << "11\n";
+        for (Iterator<A2B1C1> it = ObjectList<A2B1C1>::start(); it; ++it)
+            std::cout << "Name: " << it->getName() << "\n";
+
+        std::cout << "12\n";
+        for (Iterator<A2B1C1> it = ObjectList<A2B1C1>::end(); it; --it)
+            std::cout << "Name: " << it->getName() << "\n";
+
+        std::cout << "13\n";
+*/
+        std::cout << "Test 11\n";
+/*
+        std::cout << "1\n";
+        count = 0; for (Iterator<Tickable> it = ObjectList<Tickable>::start(); it; ++it) { count++; }
+        std::cout << "AnzahlTickable: " << count << "\n";
+
+        Test1* test11_1;
+        for (int i = 0; i < 3; i++)
+            test11_1 = new Test1;
+
+        count = 0; for (Iterator<Tickable> it = ObjectList<Tickable>::start(); it; ++it) { count++; }
+        std::cout << "AnzahlTickable: " << count << "\n";
+
+        for (Iterator<Tickable> it = ObjectList<Tickable>::start(); it; ++it)
+            it->tick(0);
+
+        std::cout << "2\n";
+        Test2* test11_2 = new Test2;
+*/
+
+        std::cout << "3\n";
+        Test3* test11_3 = new Test3;
+        test11_3->configOutput();
+
+        std::cout << "4\n";
+/*
+        std::cout << "Test 12\n";
+        std::cout << "1\n";
+
+        WorldEntity* test12_1 = new WorldEntity;
+
+        std::cout << sizeof(WorldEntity) << std::endl;
+
+        std::cout << "2\n";
+*/
+
+//    startRenderLoop();
   }
 
Index: /code/branches/core/src/orxonox/core/ConfigValueContainer.cc
===================================================================
--- /code/branches/core/src/orxonox/core/ConfigValueContainer.cc	(revision 796)
+++ /code/branches/core/src/orxonox/core/ConfigValueContainer.cc	(revision 797)
@@ -52,5 +52,5 @@
         this->searchConfigFileLine();                                               // Search the entry in the config-file
 
-        std::string valueString = this->parseValueString();                         // Parses the value string from the config-file-entry
+        std::string valueString = this->parseValueString(!(defvalue.isA(MT_string) || defvalue.isA(MT_constchar)));     // Parses the value string from the config-file-entry
         if (!this->parseString(valueString, defvalue))                              // Try to convert the string to a value
             this->resetConfigFileEntry();                                           // The conversion failed
@@ -65,27 +65,27 @@
     bool ConfigValueContainer::valueToString(std::string* output, MultiTypeMath& input)
     {
-        if (this->value_.getType() == MT_int)
+        if (input.getType() == MT_int)
             return ConvertValue(output, input.getInt(), std::string("0"));
-        else if (this->value_.getType() == MT_uint)
+        else if (input.getType() == MT_uint)
             return ConvertValue(output, input.getUnsignedInt(), std::string("0"));
-        else if (this->value_.getType() == MT_char)
-            return ConvertValue(output, input.getChar(), std::string("0"));
-        else if (this->value_.getType() == MT_uchar)
-            return ConvertValue(output, input.getUnsignedChar(), std::string("0"));
-        else if (this->value_.getType() == MT_short)
+        else if (input.getType() == MT_char)
+            return ConvertValue(output, (int)input.getChar(), std::string("0"));
+        else if (input.getType() == MT_uchar)
+            return ConvertValue(output, (unsigned int)input.getUnsignedChar(), std::string("0"));
+        else if (input.getType() == MT_short)
             return ConvertValue(output, input.getShort(), std::string("0"));
-        else if (this->value_.getType() == MT_ushort)
+        else if (input.getType() == MT_ushort)
             return ConvertValue(output, input.getUnsignedShort(), std::string("0"));
-        else if (this->value_.getType() == MT_long)
+        else if (input.getType() == MT_long)
             return ConvertValue(output, input.getLong(), std::string("0"));
-        else if (this->value_.getType() == MT_ulong)
+        else if (input.getType() == MT_ulong)
             return ConvertValue(output, input.getUnsignedLong(), std::string("0"));
-        else if (this->value_.getType() == MT_float)
+        else if (input.getType() == MT_float)
             return ConvertValue(output, input.getFloat(), std::string("0.000000"));
-        else if (this->value_.getType() == MT_double)
+        else if (input.getType() == MT_double)
             return ConvertValue(output, input.getDouble(), std::string("0.000000"));
-        else if (this->value_.getType() == MT_longdouble)
+        else if (input.getType() == MT_longdouble)
             return ConvertValue(output, input.getChar(), std::string("0.000000"));
-        else if (this->value_.getType() == MT_bool)
+        else if (input.getType() == MT_bool)
         {
             if (input.getBool())
@@ -96,15 +96,15 @@
             return true;
         }
-        else if (this->value_.getType() == MT_constchar)
+        else if (input.getType() == MT_constchar)
         {
             (*output) = "\"" + input.getString() + "\"";
             return true;
         }
-        else if (this->value_.getType() == MT_string)
+        else if (input.getType() == MT_string)
         {
             (*output) = "\"" + input.getString() + "\"";
             return true;
         }
-        else if (this->value_.getType() == MT_vector2)
+        else if (input.getType() == MT_vector2)
         {
             std::ostringstream ostream;
@@ -120,5 +120,5 @@
             }
         }
-        else if (this->value_.getType() == MT_vector3)
+        else if (input.getType() == MT_vector3)
         {
             std::ostringstream ostream;
@@ -134,5 +134,5 @@
             }
         }
-        else if (this->value_.getType() == MT_colourvalue)
+        else if (input.getType() == MT_colourvalue)
         {
             std::ostringstream ostream;
@@ -148,5 +148,5 @@
             }
         }
-        else if (this->value_.getType() == MT_quaternion)
+        else if (input.getType() == MT_quaternion)
         {
             std::ostringstream ostream;
@@ -162,7 +162,7 @@
             }
         }
-        else if (this->value_.getType() == MT_radian)
+        else if (input.getType() == MT_radian)
             return ConvertValue(output, input.getRadian(), std::string("0.000000"));
-        else if (this->value_.getType() == MT_degree)
+        else if (input.getType() == MT_degree)
             return ConvertValue(output, input.getDegree(), std::string("0.000000"));
 
@@ -177,43 +177,43 @@
     bool ConfigValueContainer::parseString(const std::string& input, MultiTypeMath& defvalue)
     {
-        if (this->value_.getType() == MT_int)
+        if (defvalue.getType() == MT_int)
             return this->parseString(input, defvalue.getInt());
-        else if (this->value_.getType() == MT_uint)
+        else if (defvalue.getType() == MT_uint)
             return this->parseString(input, defvalue.getUnsignedInt());
-        else if (this->value_.getType() == MT_char)
+        else if (defvalue.getType() == MT_char)
             return this->parseString(input, defvalue.getChar());
-        else if (this->value_.getType() == MT_uchar)
+        else if (defvalue.getType() == MT_uchar)
             return this->parseString(input, defvalue.getUnsignedChar());
-        else if (this->value_.getType() == MT_short)
+        else if (defvalue.getType() == MT_short)
             return this->parseString(input, defvalue.getShort());
-        else if (this->value_.getType() == MT_ushort)
+        else if (defvalue.getType() == MT_ushort)
             return this->parseString(input, defvalue.getUnsignedShort());
-        else if (this->value_.getType() == MT_long)
+        else if (defvalue.getType() == MT_long)
             return this->parseString(input, defvalue.getLong());
-        else if (this->value_.getType() == MT_ulong)
+        else if (defvalue.getType() == MT_ulong)
             return this->parseString(input, defvalue.getUnsignedLong());
-        else if (this->value_.getType() == MT_float)
+        else if (defvalue.getType() == MT_float)
             return this->parseString(input, defvalue.getFloat());
-        else if (this->value_.getType() == MT_double)
+        else if (defvalue.getType() == MT_double)
             return this->parseString(input, defvalue.getDouble());
-        else if (this->value_.getType() == MT_longdouble)
+        else if (defvalue.getType() == MT_longdouble)
             return this->parseString(input, defvalue.getLongDouble());
-        else if (this->value_.getType() == MT_bool)
+        else if (defvalue.getType() == MT_bool)
             return this->parseString(input, defvalue.getBool());
-        else if (this->value_.getType() == MT_constchar)
+        else if (defvalue.getType() == MT_constchar)
             return this->parseString(input, defvalue.getString());
-        else if (this->value_.getType() == MT_string)
+        else if (defvalue.getType() == MT_string)
             return this->parseString(input, defvalue.getString());
-        else if (this->value_.getType() == MT_vector2)
+        else if (defvalue.getType() == MT_vector2)
             return this->parseString(input, defvalue.getVector2());
-        else if (this->value_.getType() == MT_vector3)
+        else if (defvalue.getType() == MT_vector3)
             return this->parseString(input, defvalue.getVector3());
-        else if (this->value_.getType() == MT_colourvalue)
+        else if (defvalue.getType() == MT_colourvalue)
             return this->parseString(input, defvalue.getColourValue());
-        else if (this->value_.getType() == MT_quaternion)
+        else if (defvalue.getType() == MT_quaternion)
             return this->parseString(input, defvalue.getQuaternion());
-        else if (this->value_.getType() == MT_radian)
+        else if (defvalue.getType() == MT_radian)
             return this->parseString(input, defvalue.getRadian());
-        else if (this->value_.getType() == MT_degree)
+        else if (defvalue.getType() == MT_degree)
             return this->parseString(input, defvalue.getDegree());
 
Index: /code/branches/core/src/orxonox/core/ConfigValueContainer.h
===================================================================
--- /code/branches/core/src/orxonox/core/ConfigValueContainer.h	(revision 796)
+++ /code/branches/core/src/orxonox/core/ConfigValueContainer.h	(revision 797)
@@ -92,4 +92,5 @@
             inline ConfigValueContainer& getValue(bool* value)           { this->value_.getValue(value); return *this; }
             inline ConfigValueContainer& getValue(std::string* value)    { this->value_.getValue(value); return *this; }
+            inline ConfigValueContainer& getValue(const char** value)    { this->value_.getValue(value); return *this; }
             inline ConfigValueContainer& getValue(Vector2* value)        { this->value_.getValue(value); return *this; }
             inline ConfigValueContainer& getValue(Vector3* value)        { this->value_.getValue(value); return *this; }
Index: /code/branches/core/src/orxonox/objects/test3.cc
===================================================================
--- /code/branches/core/src/orxonox/objects/test3.cc	(revision 796)
+++ /code/branches/core/src/orxonox/objects/test3.cc	(revision 797)
@@ -51,5 +51,5 @@
         SetConfigValue(value_bool_, 1);
         SetConfigValue(value_string_, "This is a test");
-//        SetConfigValue(value_constchar_, "This is another test");
+        SetConfigValue(value_constchar_, "This is another test");
         SetConfigValue(value_vector2_, Vector2(101, 202));
         SetConfigValue(value_vector3_, Vector3(13, 26, 39));
@@ -63,16 +63,16 @@
     void Test3::configOutput()
     {
-        std::cout << this->value_int_ << std::endl;
-        std::cout << this->value_uint_ << std::endl;
-        std::cout << (int)this->value_char_ << std::endl;
-        std::cout << (int)this->value_uchar_ << std::endl;
-        std::cout << this->value_float_ << std::endl;
-        std::cout << this->value_double_ << std::endl;
-        std::cout << this->value_bool_ << std::endl;
-        std::cout << this->value_string_ << std::endl;
-        std::cout << this->value_constchar_ << std::endl;
-        std::cout << this->value_vector2_ << std::endl;
-        std::cout << this->value_vector3_ << std::endl;
-        std::cout << this->value_colourvalue_ << std::endl;
+        std::cout << "int:         " << this->value_int_ << std::endl;
+        std::cout << "uint:        " << this->value_uint_ << std::endl;
+        std::cout << "char:        " << (int)this->value_char_ << std::endl;
+        std::cout << "uchar:       " << (int)this->value_uchar_ << std::endl;
+        std::cout << "float:       " << this->value_float_ << std::endl;
+        std::cout << "double:      " << this->value_double_ << std::endl;
+        std::cout << "bool:        " << this->value_bool_ << std::endl;
+        std::cout << "string:      " << this->value_string_ << std::endl;
+        std::cout << "constchar:   " << this->value_constchar_ << std::endl;
+        std::cout << "vector2:     " << this->value_vector2_ << std::endl;
+        std::cout << "vector3:     " << this->value_vector3_ << std::endl;
+        std::cout << "colourvalue: " << this->value_colourvalue_ << std::endl;
     }
 
Index: /code/branches/core/src/util/MultiTypeMath.cc
===================================================================
--- /code/branches/core/src/util/MultiTypeMath.cc	(revision 796)
+++ /code/branches/core/src/util/MultiTypeMath.cc	(revision 797)
@@ -105,2 +105,22 @@
     this->value_ = mtm.value_;
 }
+
+std::ostream& operator<<(std::ostream& out, MultiTypeMath& mtm)
+{
+    if (mtm.isA(MT_vector2))
+        out << mtm.getVector2();
+    else if (mtm.isA(MT_vector3))
+        out << mtm.getVector3();
+    else if (mtm.isA(MT_colourvalue))
+        out << mtm.getColourValue();
+    else if (mtm.isA(MT_quaternion))
+        out << mtm.getQuaternion();
+    else if (mtm.isA(MT_radian))
+        out << mtm.getRadian();
+    else if (mtm.isA(MT_degree))
+        out << mtm.getDegree();
+    else
+        out << ((MultiTypeString)mtm);
+
+    return out;
+}
Index: /code/branches/core/src/util/MultiTypeMath.h
===================================================================
--- /code/branches/core/src/util/MultiTypeMath.h	(revision 796)
+++ /code/branches/core/src/util/MultiTypeMath.h	(revision 797)
@@ -121,3 +121,5 @@
 };
 
+std::ostream& operator<<(std::ostream& out, MultiTypeMath& mtm);
+
 #endif /* _MultiTypeMath_H__ */
Index: /code/branches/core/src/util/MultiTypePrimitive.cc
===================================================================
--- /code/branches/core/src/util/MultiTypePrimitive.cc	(revision 796)
+++ /code/branches/core/src/util/MultiTypePrimitive.cc	(revision 797)
@@ -145,2 +145,32 @@
     this->value_ = mtp.value_;
 }
+
+std::ostream& operator<<(std::ostream& out, const MultiTypePrimitive& mtp)
+{
+    if (mtp.isA(MT_int))
+        out << mtp.getInt();
+    else if (mtp.isA(MT_uint))
+        out << mtp.getUnsignedInt();
+    else if (mtp.isA(MT_char))
+        out << mtp.getChar();
+    else if (mtp.isA(MT_uchar))
+        out << mtp.getUnsignedChar();
+    else if (mtp.isA(MT_short))
+        out << mtp.getShort();
+    else if (mtp.isA(MT_ushort))
+        out << mtp.getUnsignedShort();
+    else if (mtp.isA(MT_long))
+        out << mtp.getLong();
+    else if (mtp.isA(MT_ulong))
+        out << mtp.getUnsignedLong();
+    else if (mtp.isA(MT_float))
+        out << mtp.getFloat();
+    else if (mtp.isA(MT_double))
+        out << mtp.getDouble();
+    else if (mtp.isA(MT_longdouble))
+        out << mtp.getLongDouble();
+    else if (mtp.isA(MT_bool))
+        out << mtp.getBool();
+
+    return out;
+}
Index: /code/branches/core/src/util/MultiTypePrimitive.h
===================================================================
--- /code/branches/core/src/util/MultiTypePrimitive.h	(revision 796)
+++ /code/branches/core/src/util/MultiTypePrimitive.h	(revision 797)
@@ -29,4 +29,6 @@
 #ifndef _MultiTypePrimitive_H__
 #define _MultiTypePrimitive_H__
+
+#include <ostream>
 
 #include "UtilPrereqs.h"
@@ -142,3 +144,5 @@
 };
 
+std::ostream& operator<<(std::ostream& out, const MultiTypePrimitive& mtp);
+
 #endif /* _MultiTypePrimitive_H__ */
Index: /code/branches/core/src/util/MultiTypeString.cc
===================================================================
--- /code/branches/core/src/util/MultiTypeString.cc	(revision 796)
+++ /code/branches/core/src/util/MultiTypeString.cc	(revision 797)
@@ -81,2 +81,14 @@
     this->value_ = mts.value_;
 }
+
+std::ostream& operator<<(std::ostream& out, MultiTypeString& mts)
+{
+    if (mts.isA(MT_constchar))
+        out << mts.getConstChar();
+    else if (mts.isA(MT_string))
+        out << mts.getString();
+    else
+        out << ((MultiTypePrimitive)mts);
+
+    return out;
+}
Index: /code/branches/core/src/util/MultiTypeString.h
===================================================================
--- /code/branches/core/src/util/MultiTypeString.h	(revision 796)
+++ /code/branches/core/src/util/MultiTypeString.h	(revision 797)
@@ -76,8 +76,10 @@
         void setValue(const MultiTypeString& mtp);
 
-        inline std::string& getString() { return this->string_; }
+        inline std::string& getString()    { return this->string_; }
+        inline const char*  getConstChar() { return this->string_.c_str(); }
 
         using MultiTypePrimitive::getValue;
-        inline void getValue(std::string* variable) const { (*variable) = std::string(this->string_); }
+        inline void getValue(std::string* variable) const { (*variable) = this->string_; }
+        inline void getValue(const char** variable) const { (*variable) = this->string_.c_str(); }
 
     protected:
@@ -85,3 +87,5 @@
 };
 
+std::ostream& operator<<(std::ostream& out, MultiTypeString& mts);
+
 #endif /* _MultiTypeString_H__ */
