Changeset 10624 for code/trunk/src/libraries/core

code/trunk

Property svn:mergeinfo changed

merged: 10328,10342-10349,10352-10367,10370-10377,10379-10382,10392-10393,10395-10396,10398-10405,10407,10410-10422,10424,10458-10484,10508-10544,10547-10583

code/trunk/src/libraries/core/BaseObject.cc

-                      r9667
+                      r10624
         this->bActive_ = true;
         this->bVisible_ = true;
-        this->oldGametype_ = 0;
         this->bRegisteredEventStates_ = false;
 …
+        {
             this->setFile(this->creator_->getFile());
+            this->setNamespace(this->creator_->getNamespace());
+            this->setScene(this->creator_->getScene(), this->creator_->getSceneID());
+            this->setGametype(this->creator_->getGametype());
+            this->setLevel(this->creator_->getLevel());
+            // store strong-pointers on all four base objects by default (can be overwritten with weak-ptr after the constructor if necessary)
+            this->setNamespace(this->creator_->namespace_.createStrongPtr());
+            this->setScene    (this->creator_->scene_    .createStrongPtr(), this->creator_->sceneID_);
+            this->setGametype (this->creator_->gametype_ .createStrongPtr());
+            this->setLevel    (this->creator_->level_    .createStrongPtr());
+        }
         else
+        {
             this->file_ = 0;
-            this->namespace_ = 0;
-            this->scene_ = 0;
             this->sceneID_ = OBJECTID_UNKNOWN;
-            this->gametype_ = 0;
-            this->level_ = 0;
+        }
+    }

code/trunk/src/libraries/core/BaseObject.h

-                      r10298
+                      r10624
 #include "class/OrxonoxClass.h"
 #include "class/Super.h"
 #include "object/SmartPtr.h"
+#include "object/StrongPtr.h"
 namespace orxonox
 …
+    {
         template <class T> friend class XMLPortClassParamContainer;
+        public:
+            template <class T>
+            class StrongOrWeakPtr
+            {
+                public:
+                    inline StrongOrWeakPtr();
+                    inline StrongOrWeakPtr(const StrongPtr<T>& ptr);
+                    inline StrongOrWeakPtr(const WeakPtr<T>& ptr);
+                    inline T* get() const;
+                    inline StrongPtr<T> createStrongPtr() const;
+                private:
+                    StrongPtr<T> strongPtr_;
+                    WeakPtr<T> weakPtr_;
+            };
         public:
 …
                 { return this->templates_; }
             inline void setNamespace(const SmartPtr<Namespace>& ns) { this->namespace_ = ns; }
             inline const SmartPtr<Namespace>& getNamespace() const { return this->namespace_; }
+            inline void setNamespace(const StrongOrWeakPtr<Namespace>& ns) { this->namespace_ = ns; }
+            inline Namespace* getNamespace() const { return this->namespace_.get(); }
             inline void setCreator(BaseObject* creator) { this->creator_ = creator; }
             inline BaseObject* getCreator() const { return this->creator_; }
             inline void setScene(const SmartPtr<Scene>& scene, uint32_t sceneID) { this->scene_ = scene; this->sceneID_=sceneID; }
             inline const SmartPtr<Scene>& getScene() const { return this->scene_; }
+            inline void setScene(const StrongOrWeakPtr<Scene>& scene, uint32_t sceneID) { this->scene_ = scene; this->sceneID_=sceneID; }
+            inline Scene* getScene() const { return this->scene_.get(); }
             inline virtual uint32_t getSceneID() const { return this->sceneID_; }
+            inline void setGametype(const SmartPtr<Gametype>& gametype)
+            {
+                if (gametype != this->gametype_)
+                {
+                    this->oldGametype_ = this->gametype_;
+                    this->gametype_ = gametype;
+                    this->changedGametype();
+                }
+            }
+            inline const SmartPtr<Gametype>& getGametype() const { return this->gametype_; }
+            inline Gametype* getOldGametype() const { return this->oldGametype_; }
+            virtual void changedGametype() {}
+            inline void setLevel(const SmartPtr<Level>& level)
+            {
+                if (level != this->level_)
+                {
+                    this->level_ = level;
+                    this->changedLevel();
+                }
+            }
+            inline const SmartPtr<Level>& getLevel() const { return this->level_; }
+            virtual void changedLevel() {}
+            inline void setGametype(const StrongOrWeakPtr<Gametype>& gametype) { this->gametype_ = gametype; }
+            inline Gametype* getGametype() const { return this->gametype_.get(); }
+            inline void setLevel(const StrongOrWeakPtr<Level>& level) { this->level_ = level; }
+            inline Level* getLevel() const { return this->level_.get(); }
             void addEventSource(BaseObject* source, const std::string& state);
 …
             void registerEventStates();
             bool                   bInitialized_;              //!< True if the object was initialized (passed the object registration)
             const XMLFile*         file_;                      //!< The XMLFile that loaded this object
             Element*               lastLoadedXMLElement_;      //!< Non 0 if the TinyXML attributes have already been copied to our own lowercase map
+            bool                       bInitialized_;          //!< True if the object was initialized (passed the object registration)
+            const XMLFile*             file_;                  //!< The XMLFile that loaded this object
+            Element*                   lastLoadedXMLElement_;  //!< Non 0 if the TinyXML attributes have already been copied to our own lowercase map
             std::map<std::string, std::string> xmlAttributes_; //!< Lowercase XML attributes
+            std::string            loaderIndentation_;         //!< Indentation of the debug output in the Loader
+            SmartPtr<Namespace>    namespace_;
+            BaseObject*            creator_;
+            SmartPtr<Scene>        scene_;
+            uint32_t               sceneID_;
+            SmartPtr<Gametype>     gametype_;
+            Gametype*              oldGametype_;
+            SmartPtr<Level>        level_;
+            std::set<Template*>    templates_;
+            std::string                loaderIndentation_;     //!< Indentation of the debug output in the Loader
+            StrongOrWeakPtr<Namespace> namespace_;
+            BaseObject*                creator_;
+            StrongOrWeakPtr<Scene>     scene_;
+            uint32_t                   sceneID_;
+            StrongOrWeakPtr<Gametype>  gametype_;
+            StrongOrWeakPtr<Level>     level_;
+            std::set<Template*>        templates_;
             std::map<BaseObject*, std::string>  eventSources_;           //!< List of objects which send events to this object, mapped to the state which they affect
 …
     SUPER_FUNCTION(4, BaseObject, XMLEventPort, false);
     SUPER_FUNCTION(8, BaseObject, changedName, false);
+    SUPER_FUNCTION(9, BaseObject, changedGametype, false);
+    template <class T>
+    BaseObject::StrongOrWeakPtr<T>::StrongOrWeakPtr()
+    {
+    }
+    template <class T>
+    BaseObject::StrongOrWeakPtr<T>::StrongOrWeakPtr(const StrongPtr<T>& ptr) : strongPtr_(ptr)
+    {
+    }
+    template <class T>
+    BaseObject::StrongOrWeakPtr<T>::StrongOrWeakPtr(const WeakPtr<T>& ptr) : weakPtr_(ptr)
+    {
+    }
+    template <class T>
+    T* BaseObject::StrongOrWeakPtr<T>::get() const
+    {
+        if (this->strongPtr_)
+            return this->strongPtr_;
+        else if (this->weakPtr_)
+            return this->weakPtr_;
+        else
+            return NULL;
+    }
+    template <class T>
+    StrongPtr<T> BaseObject::StrongOrWeakPtr<T>::createStrongPtr() const
+    {
+        if (this->strongPtr_)
+            return this->strongPtr_; // creates a copy
+        else
+            return this->weakPtr_; // converts automatically to StrongPtr
+    }
+}

code/trunk/src/libraries/core/CMakeLists.txt

-                      r10268
+                      r10624
 #BUILD_UNIT CoreStableBuildUnit.cc
   ClassTreeMask.cc
-  DynLib.cc
-  DynLibManager.cc
   Event.cc
   Game.cc
+  GameConfig.cc
   GameMode.cc
   GameState.cc
 …
   NamespaceNode.cc
   Template.cc
+  UpdateListener.cc
   ViewportEventListener.cc
   WindowEventListener.cc
 …
   BaseObject.cc
   Core.cc
+  CoreConfig.cc
+  CoreStaticInitializationHandler.cc
 BUILD_UNIT OgreBuildUnit.cc
 …
   command/ArgumentCompletionFunctions.cc
   config/ConfigFile.cc
+  PathConfig.cc
+  ApplicationPaths.cc
+  ConfigurablePaths.cc
 END_BUILD_UNIT
 …
 ADD_SUBDIRECTORY(class)
 ADD_SUBDIRECTORY(command)
+ADD_SUBDIRECTORY(commandline)
 ADD_SUBDIRECTORY(config)
 ADD_SUBDIRECTORY(input)
+ADD_SUBDIRECTORY(module)
 ADD_SUBDIRECTORY(object)
+ADD_SUBDIRECTORY(singleton)
 #Add the icon (for the renderwindow)
 …
     command/CommandExecutor.h
     config/SettingsConfigFile.h
+    ApplicationPaths.h
+    ConfigurablePaths.h
     Game.h
     GameMode.h
 …
     Loader.h
     LuaState.h
-    PathConfig.h
     input/InputManager.h
     input/KeyBinder.h

code/trunk/src/libraries/core/ClassTreeMask.cc

-                      r9667
+                      r10624
+        {
             // No it's not: Search for classes inheriting from the given class and add the rules for them
             for (std::set<const Identifier*>::const_iterator it = subclass->getDirectChildrenBegin(); it != subclass->getDirectChildrenEnd(); ++it)
+            for (std::set<const Identifier*>::const_iterator it = subclass->getDirectChildren().begin(); it != subclass->getDirectChildren().end(); ++it)
                 if ((*it)->isA(this->root_->getClass()))
                     if (overwrite || (!this->nodeExists(*it))) // If we don't want to overwrite, only add nodes that don't already exist
 …
         if (!subclass)
             return;
         for (std::set<const Identifier*>::const_iterator it = subclass->getDirectChildrenBegin(); it != subclass->getDirectChildrenEnd(); ++it)
+        for (std::set<const Identifier*>::const_iterator it = subclass->getDirectChildren().begin(); it != subclass->getDirectChildren().end(); ++it)
             this->add(*it, this->isIncluded(*it), false, false);
 …
                                 // Insert all directChildren of the directChild
                                 directChildren.insert((*it2)->getDirectChildrenBegin(), (*it2)->getDirectChildrenEnd());
+                                directChildren.insert((*it2)->getDirectChildren().begin(), (*it2)->getDirectChildren().end());
                                 // Restart the scan with the expanded set of directChildren

code/trunk/src/libraries/core/Core.cc

-                      r9667
+                      r10624
 #include "util/Output.h"
 #include "util/Exception.h"
+#include "util/SignalHandler.h"
 #include "util/output/LogWriter.h"
 #include "util/output/OutputManager.h"
+#include "util/Scope.h"
+#include "util/ScopedSingletonManager.h"
+#include "util/SignalHandler.h"
+#include "PathConfig.h"
+#include "config/CommandLineParser.h"
+#include "core/singleton/Scope.h"
+#include "ApplicationPaths.h"
+#include "ConfigurablePaths.h"
+#include "commandline/CommandLineIncludes.h"
 #include "config/ConfigFileManager.h"
-#include "config/ConfigValueIncludes.h"
-#include "CoreIncludes.h"
-#include "DynLibManager.h"
 #include "GameMode.h"
 #include "GraphicsManager.h"
 #include "GUIManager.h"
-#include "class/Identifier.h"
 #include "Language.h"
+#include "Loader.h"
 #include "LuaState.h"
-#include "command/ConsoleCommand.h"
 #include "command/IOConsole.h"
 #include "command/TclBind.h"
 …
 #include "input/InputManager.h"
 #include "object/ObjectList.h"
+#include "module/DynLibManager.h"
+#include "module/ModuleInstance.h"
+#include "module/StaticInitializationManager.h"
+#include "module/PluginManager.h"
+#include "CoreStaticInitializationHandler.h"
+#include "UpdateListener.h"
 namespace orxonox
 …
 #endif
-    // register Core as an abstract class to avoid problems if the class hierarchy is created within Core-constructor
-    RegisterAbstractClass(Core).inheritsFrom(Class(Configurable));
     Core::Core(const std::string& cmdLine)
+        : pathConfig_(NULL)
+        : applicationPaths_(NULL)
+        , configurablePaths_(NULL)
         , dynLibManager_(NULL)
         , signalHandler_(NULL)
         , configFileManager_(NULL)
         , languageInstance_(NULL)
+        , loaderInstance_(NULL)
         , ioConsole_(NULL)
         , tclBind_(NULL)
 …
         , graphicsScope_(NULL)
         , bGraphicsLoaded_(false)
         , bStartIOConsole_(true)
         , lastLevelTimestamp_(0)
         , ogreConfigTimestamp_(0)
         , bDevMode_(false)
+        , staticInitHandler_(NULL)
+        , pluginManager_(NULL)
+        , rootModule_(NULL)
+        , config_(NULL)
         , destructionHelper_(this)
+    {
 …
         // Set the hard coded fixed paths
         this->pathConfig_ = new PathConfig();
+        this->applicationPaths_ = new ApplicationPaths();
         // Create a new dynamic library manager
         this->dynLibManager_ = new DynLibManager();
+        // Load modules
+        orxout(internal_info) << "Loading modules:" << endl;
+        const std::vector<std::string>& modulePaths = this->pathConfig_->getModulePaths();
+        for (std::vector<std::string>::const_iterator it = modulePaths.begin(); it != modulePaths.end(); ++it)
+        {
+            try
+            {
+                this->dynLibManager_->load(*it);
+            }
+            catch (...)
+            {
+                orxout(user_error) << "Couldn't load module \"" << *it << "\": " << Exception::handleMessage() << endl;
+            }
+        }
+        // create handler for static initialization
+        new StaticInitializationManager(); // create singleton
+        this->staticInitHandler_ = new CoreStaticInitializationHandler();
+        StaticInitializationManager::getInstance().addHandler(this->staticInitHandler_);
+        // load root module (all libraries which are linked to the executable, including core, network, and orxonox)
+        this->rootModule_ = ModuleInstance::getCurrentModuleInstance();
+        StaticInitializationManager::getInstance().loadModule(this->rootModule_);
         // Parse command line arguments AFTER the modules have been loaded (static code!)
 …
         // Set configurable paths like log, config and media
+        this->pathConfig_->setConfigurablePaths();
+        orxout(internal_info) << "Root path:       " << PathConfig::getRootPathString() << endl;
+        orxout(internal_info) << "Executable path: " << PathConfig::getExecutablePathString() << endl;
+        orxout(internal_info) << "Data path:       " << PathConfig::getDataPathString() << endl;
+        orxout(internal_info) << "Ext. data path:  " << PathConfig::getExternalDataPathString() << endl;
+        orxout(internal_info) << "Config path:     " << PathConfig::getConfigPathString() << endl;
+        orxout(internal_info) << "Log path:        " << PathConfig::getLogPathString() << endl;
+        orxout(internal_info) << "Modules path:    " << PathConfig::getModulePathString() << endl;
+        // create a signal handler (only active for Linux)
+        this->configurablePaths_ = new ConfigurablePaths();
+        this->configurablePaths_->setConfigurablePaths(ApplicationPaths::getInstance());
+        orxout(internal_info) << "Root path:       " << ApplicationPaths::getRootPathString() << endl;
+        orxout(internal_info) << "Executable path: " << ApplicationPaths::getExecutablePathString() << endl;
+        orxout(internal_info) << "Modules path:    " << ApplicationPaths::getModulePathString() << endl;
+        orxout(internal_info) << "Plugins path:    " << ApplicationPaths::getPluginPathString() << endl;
+        orxout(internal_info) << "Data path:       " << ConfigurablePaths::getDataPathString() << endl;
+        orxout(internal_info) << "Ext. data path:  " << ConfigurablePaths::getExternalDataPathString() << endl;
+        orxout(internal_info) << "Config path:     " << ConfigurablePaths::getConfigPathString() << endl;
+        orxout(internal_info) << "Log path:        " << ConfigurablePaths::getLogPathString() << endl;
+        // create a signal handler
         // This call is placed as soon as possible, but after the directories are set
         this->signalHandler_ = new SignalHandler();
         this->signalHandler_->doCatch(PathConfig::getExecutablePathString(), PathConfig::getLogPathString() + "orxonox_crash.log");
+        this->signalHandler_->doCatch(ApplicationPaths::getExecutablePathString(), ConfigurablePaths::getLogPathString() + "orxonox_crash.log");
 #ifdef ORXONOX_PLATFORM_WINDOWS
 …
         this->languageInstance_ = new Language();
+        // initialize root context
+        Context::setRootContext(new Context(NULL));
         // Do this soon after the ConfigFileManager has been created to open up the
         // possibility to configure everything below here
-        RegisterObject(Core);
         orxout(internal_info) << "configuring Core" << endl;
         this->setConfigValues();
+        this->config_ = new CoreConfig();
         // Set the correct log path and rewrite the log file with the correct log levels
         OutputManager::getInstance().getLogWriter()->setLogDirectory(PathConfig::getLogPathString());
+        OutputManager::getInstance().getLogWriter()->setLogDirectory(ConfigurablePaths::getLogPathString());
 #if !defined(ORXONOX_PLATFORM_APPLE) && !defined(ORXONOX_USE_WINMAIN)
         // Create persistent IO console
+        if (CommandLineParser::getValue("noIOConsole").get<bool>())
+        {
+            ModifyConfigValue(bStartIOConsole_, tset, false);
+        }
+        if (this->bStartIOConsole_)
+        if (CommandLineParser::getValue("noIOConsole").get<bool>() == false && this->config_->getStartIOConsole())
+        {
             orxout(internal_info) << "creating IO console" << endl;
 …
         // creates the class hierarchy for all classes with factories
         orxout(internal_info) << "creating class hierarchy" << endl;
+        IdentifierManager::getInstance().createClassHierarchy();
+        this->staticInitHandler_->initInstances(this->rootModule_);
+        this->staticInitHandler_->setInitInstances(true);
+        // Create plugin manager and search for plugins
+        this->pluginManager_ = new PluginManager();
+        this->pluginManager_->findPlugins();
+        // Loader
+        this->loaderInstance_ = new Loader();
         // Load OGRE excluding the renderer and the render window
 …
         // initialise Tcl
         this->tclBind_ = new TclBind(PathConfig::getDataPathString());
+        this->tclBind_ = new TclBind(ConfigurablePaths::getDataPathString());
         this->tclThreadManager_ = new TclThreadManager(tclBind_->getTclInterpreter());
         // Create singletons that always exist (in other libraries)
         orxout(internal_info) << "creating root scope:" << endl;
         this->rootScope_ = new Scope<ScopeID::Root>();
+        this->rootScope_ = new Scope<ScopeID::ROOT>();
         // Generate documentation instead of normal run?
 …
         orxout(internal_status) << "destroying Core object..." << endl;
-        // Remove us from the object lists again to avoid problems when destroying them
-        this->unregisterObject();
         safeObjectDelete(&graphicsScope_);
         safeObjectDelete(&guiManager_);
 …
         safeObjectDelete(&tclBind_);
         safeObjectDelete(&ioConsole_);
+        safeObjectDelete(&loaderInstance_);
+        safeObjectDelete(&config_);
         safeObjectDelete(&languageInstance_);
         safeObjectDelete(&configFileManager_);
-        ConsoleCommand::destroyAll();
-        Context::setRootContext(NULL);
-        IdentifierManager::getInstance().destroyAllIdentifiers();
         safeObjectDelete(&signalHandler_);
+        safeObjectDelete(&pluginManager_);
+        Context::getRootContext()->unregisterObject(); // unregister context from object lists - otherwise the root context would be destroyed while unloading the root module
+        if (this->rootModule_)
+        {
+            StaticInitializationManager::getInstance().unloadModule(this->rootModule_);
+            this->rootModule_->deleteAllStaticallyInitializedInstances();
+        }
+        if (this->staticInitHandler_)
+            StaticInitializationManager::getInstance().removeHandler(this->staticInitHandler_);
+        Context::destroyRootContext();
+        safeObjectDelete(&rootModule_);
+        safeObjectDelete(&staticInitHandler_);
+        delete &StaticInitializationManager::getInstance();
         safeObjectDelete(&dynLibManager_);
+        safeObjectDelete(&pathConfig_);
+        safeObjectDelete(&configurablePaths_);
+        safeObjectDelete(&applicationPaths_);
         orxout(internal_status) << "finished destroying Core object" << endl;
+    }
+    //! Function to collect the SetConfigValue-macro calls.
+    void Core::setConfigValues()
+    {
+        SetConfigValueExternal(OutputManager::getInstance().getLogWriter()->configurableMaxLevel_,
+                               OutputManager::getInstance().getLogWriter()->getConfigurableSectionName(),
+                               OutputManager::getInstance().getLogWriter()->getConfigurableMaxLevelName(),
+                               OutputManager::getInstance().getLogWriter()->configurableMaxLevel_)
+            .description("The maximum level of output shown in the log file")
+            .callback(static_cast<BaseWriter*>(OutputManager::getInstance().getLogWriter()), &BaseWriter::changedConfigurableLevel);
+        SetConfigValueExternal(OutputManager::getInstance().getLogWriter()->configurableAdditionalContextsMaxLevel_,
+                               OutputManager::getInstance().getLogWriter()->getConfigurableSectionName(),
+                               OutputManager::getInstance().getLogWriter()->getConfigurableAdditionalContextsMaxLevelName(),
+                               OutputManager::getInstance().getLogWriter()->configurableAdditionalContextsMaxLevel_)
+            .description("The maximum level of output shown in the log file for additional contexts")
+            .callback(static_cast<BaseWriter*>(OutputManager::getInstance().getLogWriter()), &BaseWriter::changedConfigurableAdditionalContextsLevel);
+        SetConfigValueExternal(OutputManager::getInstance().getLogWriter()->configurableAdditionalContexts_,
+                               OutputManager::getInstance().getLogWriter()->getConfigurableSectionName(),
+                               OutputManager::getInstance().getLogWriter()->getConfigurableAdditionalContextsName(),
+                               OutputManager::getInstance().getLogWriter()->configurableAdditionalContexts_)
+            .description("Additional output contexts shown in the log file")
+            .callback(static_cast<BaseWriter*>(OutputManager::getInstance().getLogWriter()), &BaseWriter::changedConfigurableAdditionalContexts);
+        SetConfigValue(bDevMode_, PathConfig::buildDirectoryRun())
+            .description("Developer mode. If not set, hides some things from the user to not confuse him.")
+            .callback(this, &Core::devModeChanged);
+        SetConfigValue(language_, Language::getInstance().defaultLanguage_)
+            .description("The language of the in game text")
+            .callback(this, &Core::languageChanged);
+        SetConfigValue(bInitRandomNumberGenerator_, true)
+            .description("If true, all random actions are different each time you start the game")
+            .callback(this, &Core::initRandomNumberGenerator);
+        SetConfigValue(bStartIOConsole_, true)
+            .description("Set to false if you don't want to use the IOConsole (for Lua debugging for instance)");
+        SetConfigValue(lastLevelTimestamp_, 0)
+            .description("Timestamp when the last level was started.");
+        SetConfigValue(ogreConfigTimestamp_, 0)
+            .description("Timestamp when the ogre config file was changed.");
+    }
+    /** Callback function for changes in the dev mode that affect debug levels.
+        The function behaves according to these rules:
+        - 'normal' mode is defined based on where the program was launched: if
+          the launch path was the build directory, development mode \c on is
+          normal, otherwise normal means development mode \c off.
+        - Debug levels should not be hard configured (\c config instead of
+          \c tconfig) in non 'normal' mode to avoid strange behaviour.
+        - Changing the development mode from 'normal' to the other state will
+          immediately change the debug levels to predefined values which can be
+          reconfigured with \c tconfig.
+    @note
+        The debug levels for the IOConsole and the InGameConsole can be found
+        in the Shell class. The same rules apply.
+    */
+    void Core::devModeChanged()
+    {
+        // Inform listeners
+        ObjectList<DevModeListener>::iterator it = ObjectList<DevModeListener>::begin();
+        for (; it != ObjectList<DevModeListener>::end(); ++it)
+            it->devModeChanged(bDevMode_);
+    }
+    //! Callback function if the language has changed.
+    void Core::languageChanged()
+    {
+        // Read the translation file after the language was configured
+        Language::getInstance().readTranslatedLanguageFile();
+    }
+    void Core::initRandomNumberGenerator()
+    {
+        static bool bInitialized = false;
+        if (!bInitialized && this->bInitRandomNumberGenerator_)
+        {
+            srand(static_cast<unsigned int>(time(0)));
+            rand();
+            bInitialized = true;
+        }
+    void Core::loadModules()
+    {
+        orxout(internal_info) << "Loading modules:" << endl;
+        const std::vector<std::string>& modulePaths = ApplicationPaths::getInstance().getModulePaths();
+        for (std::vector<std::string>::const_iterator it = modulePaths.begin(); it != modulePaths.end(); ++it)
+        {
+            ModuleInstance* module = new ModuleInstance(*it);
+            this->loadModule(module);
+            this->modules_.push_back(module);
+        }
+        orxout(internal_info) << "finished loading modules" << endl;
+    }
+    void Core::loadModule(ModuleInstance* module)
+    {
+        orxout(internal_info) << "Loading module " << module->getLibraryName() << "..." << endl;
+        try
+        {
+            ModuleInstance::setCurrentModuleInstance(module);
+            DynLib* dynLib = this->dynLibManager_->load(module->getLibraryName());
+            module->setDynLib(dynLib);
+            StaticInitializationManager::getInstance().loadModule(module);
+        }
+        catch (...)
+        {
+            orxout(user_error) << "Couldn't load module \"" << module->getLibraryName() << "\": " << Exception::handleMessage() << endl;
+        }
+    }
+    void Core::unloadModules()
+    {
+        for (std::list<ModuleInstance*>::iterator it = this->modules_.begin(); it != this->modules_.end(); ++it)
+        {
+            ModuleInstance* module = (*it);
+            this->unloadModule(module);
+            delete module;
+        }
+        this->modules_.clear();
+    }
+    void Core::unloadModule(ModuleInstance* module)
+    {
+        orxout(internal_info) << "Unloading module " << module->getLibraryName() << "..." << endl;
+        StaticInitializationManager::getInstance().unloadModule(module);
+        module->deleteAllStaticallyInitializedInstances();
+        this->dynLibManager_->unload(module->getDynLib());
+        module->setDynLib(NULL);
+    }
 …
         // Any exception should trigger this, even in upgradeToGraphics (see its remarks)
         Loki::ScopeGuard unloader = Loki::MakeObjGuard(*this, &Core::unloadGraphics);
+        Loki::ScopeGuard unloader = Loki::MakeObjGuard(*this, &Core::unloadGraphics, true);
         // Upgrade OGRE to receive a render window
 …
         // Create singletons associated with graphics (in other libraries)
         orxout(internal_info) << "creating graphics scope:" << endl;
         graphicsScope_ = new Scope<ScopeID::Graphics>();
+        graphicsScope_ = new Scope<ScopeID::GRAPHICS>();
         unloader.Dismiss();
 …
+    }
     void Core::unloadGraphics()
+    void Core::unloadGraphics(bool loadGraphicsManagerWithoutRenderer)
+    {
         orxout(internal_info) << "unloading graphics in Core" << endl;
+        if (this->graphicsManager_)
+            this->graphicsManager_->unloadDebugOverlay();
         safeObjectDelete(&graphicsScope_);
 …
         // Load Ogre::Root again, but without the render system
         try
+            { this->graphicsManager_ = new GraphicsManager(false); }
+        {
+            if (loadGraphicsManagerWithoutRenderer)
+                this->graphicsManager_ = new GraphicsManager(false);
+        }
         catch (...)
+        {
 …
         bGraphicsLoaded_ = false;
         GameMode::bShowsGraphics_s = false;
+    }
-    //! Sets the language in the config-file back to the default.
-    void Core::resetLanguage()
+    {
-        ResetConfigValue(language_);
+    }
 …
     void Core::preUpdate(const Clock& time)
+    {
+        // Update singletons before general ticking
+        ScopedSingletonManager::preUpdate<ScopeID::Root>(time);
+        // Update UpdateListeners before general ticking
+        for (ObjectList<UpdateListener>::iterator it = ObjectList<UpdateListener>::begin(); it != ObjectList<UpdateListener>::end(); ++it)
+            it->preUpdate(time);
         if (this->bGraphicsLoaded_)
+        {
 …
             // Update GUI
             this->guiManager_->preUpdate(time);
-            // Update singletons before general ticking
-            ScopedSingletonManager::preUpdate<ScopeID::Graphics>(time);
+        }
         // Process console events and status line
 …
     void Core::postUpdate(const Clock& time)
+    {
+        // Update singletons just before rendering
+        ScopedSingletonManager::postUpdate<ScopeID::Root>(time);
+        // Update UpdateListeners just before rendering
+        for (ObjectList<UpdateListener>::iterator it = ObjectList<UpdateListener>::begin(); it != ObjectList<UpdateListener>::end(); ++it)
+            it->postUpdate(time);
         if (this->bGraphicsLoaded_)
+        {
-            // Update singletons just before rendering
-            ScopedSingletonManager::postUpdate<ScopeID::Graphics>(time);
             // Render (doesn't throw)
             this->graphicsManager_->postUpdate(time);
+        }
+    }
-    void Core::updateLastLevelTimestamp()
+    {
-        ModifyConfigValue(lastLevelTimestamp_, set, static_cast<long long>(time(NULL)));
+    }
-    void Core::updateOgreConfigTimestamp()
+    {
-        ModifyConfigValue(ogreConfigTimestamp_, set, static_cast<long long>(time(NULL)));
+    }
-    RegisterAbstractClass(DevModeListener).inheritsFrom(Class(Listable));
-    DevModeListener::DevModeListener()
+    {
-        RegisterObject(DevModeListener);
+    }
+}

code/trunk/src/libraries/core/Core.h

-                      r9667
+                      r10624
 #include "util/DestructionHelper.h"
 #include "util/Singleton.h"
 #include "config/Configurable.h"
+#include "CoreConfig.h"
 namespace orxonox
+{
-    //! Informs about changes in the Development Mode.
-    class DevModeListener : virtual public Listable
+    {
-    public:
-        DevModeListener();
-        virtual ~DevModeListener() {}
-        virtual void devModeChanged(bool value) = 0;
-    };
     /**
     @brief
 …
         You should only create this singleton once because it destroys the identifiers!
     */
     class _CoreExport Core : public Singleton<Core>, public Configurable
+    class _CoreExport Core : public Singleton<Core>
+    {
         friend class Singleton<Core>;
-        friend class Game;
         public:
 …
             void destroy();
+            void setConfigValues();
+            void preUpdate(const Clock& time);
+            void postUpdate(const Clock& time);
+            //! Returns the configured language.
+            const std::string& getLanguage()
+                { return this->language_; }
+            void resetLanguage();
+            void loadGraphics();
+            void unloadGraphics(bool loadGraphicsManagerWithoutRenderer = true);
+            void updateLastLevelTimestamp();
+            inline long long getLastLevelTimestamp() const
+                { return this->lastLevelTimestamp_; }
+            void loadModules();
+            void unloadModules();
+            void loadModule(ModuleInstance* module);
+            void unloadModule(ModuleInstance* module);
+            void updateOgreConfigTimestamp();
+            inline long long getOgreConfigTimestamp() const
+                { return this->ogreConfigTimestamp_; }
+            //! Developers bit. If returns false, some options are not available as to not confuse the normal user.
+            inline bool inDevMode(void) const
+                { return this->bDevMode_; }
+            inline CoreConfig* getConfig() const
+                { return this->config_; }
         private:
             Core(const Core&); //!< Don't use (undefined symbol)
-            void devModeChanged();
-            void languageChanged();
-            void initRandomNumberGenerator();
-            void preUpdate(const Clock& time);
-            void postUpdate(const Clock& time);
-            void loadGraphics();
-            void unloadGraphics();
             void setThreadAffinity(int limitToCPU);
+            PathConfig*               pathConfig_;
+            DynLibManager*            dynLibManager_;
+            SignalHandler*            signalHandler_;
+            ConfigFileManager*        configFileManager_;
+            Language*                 languageInstance_;
+            IOConsole*                ioConsole_;
+            TclBind*                  tclBind_;
+            TclThreadManager*         tclThreadManager_;
+            Scope<ScopeID::Root>*     rootScope_;
+            ApplicationPaths*                applicationPaths_;
+            ConfigurablePaths*               configurablePaths_;
+            DynLibManager*                   dynLibManager_;
+            SignalHandler*                   signalHandler_;
+            ConfigFileManager*               configFileManager_;
+            Language*                        languageInstance_;
+            Loader*                          loaderInstance_;
+            IOConsole*                       ioConsole_;
+            TclBind*                         tclBind_;
+            TclThreadManager*                tclThreadManager_;
+            Scope<ScopeID::ROOT>*            rootScope_;
             // graphical
+            GraphicsManager*          graphicsManager_;            //!< Interface to OGRE
+            InputManager*             inputManager_;               //!< Interface to OIS
+            GUIManager*               guiManager_;                 //!< Interface to GUI
+            Scope<ScopeID::Graphics>* graphicsScope_;
+            GraphicsManager*                 graphicsManager_;            //!< Interface to OGRE
+            InputManager*                    inputManager_;               //!< Interface to OIS
+            GUIManager*                      guiManager_;                 //!< Interface to GUI
+            Scope<ScopeID::GRAPHICS>*        graphicsScope_;
+            bool                             bGraphicsLoaded_;
             bool                      bGraphicsLoaded_;
             std::string               language_;                   //!< The language
             bool                      bInitRandomNumberGenerator_; //!< If true, srand(time(0)) is called
             bool                      bStartIOConsole_;            //!< Set to false if you don't want to use the IOConsole
+            long long                 lastLevelTimestamp_;         ///< Timestamp when the last level was started
             long long                 ogreConfigTimestamp_;        ///< Timestamp wehen the ogre config level was modified
             bool                      bDevMode_;                   //!< Developers bit. If set to false, some options are not available as to not confuse the normal user.
+            CoreStaticInitializationHandler* staticInitHandler_;
+            PluginManager*                   pluginManager_;
+            ModuleInstance*                  rootModule_;
+            std::list<ModuleInstance*>       modules_;
+            /// Helper object that stores the config values
+            CoreConfig*                      config_;
             /// Helper object that executes the surrogate destructor destroy()
             DestructionHelper<Core>   destructionHelper_;
+            DestructionHelper<Core>          destructionHelper_;
             static Core*              singletonPtr_s;
+            static Core*                     singletonPtr_s;
     };
+}

code/trunk/src/libraries/core/CoreIncludes.h

-                      r10208
+                      r10624
 #include "object/ClassFactory.h"
 #include "object/ObjectList.h"
+#include "module/StaticallyInitializedInstance.h"
 // resolve macro conflict on windows
 …
 */
 #define RegisterClassWithFactory(ClassName, FactoryInstance, bLoadable) \
     Identifier& _##ClassName##Identifier = orxonox::registerClass<ClassName>(#ClassName, FactoryInstance, bLoadable)
+    orxonox::SI_I& _##ClassName##Identifier = (*new orxonox::SI_I(orxonox::registerClass<ClassName>(#ClassName, FactoryInstance, bLoadable)))
 /**
 …
 */
 #define RegisterObject(ClassName) \
     if (ClassIdentifier<ClassName>::getIdentifier(#ClassName)->initializeObject(this)) \
+    if (ClassIdentifier<ClassName>::getIdentifier()->initializeObject(this)) \
         return; \
     else \
 …
      */
     template <class T>
     inline Identifier& registerClass(const std::string& name, ClassFactory<T>* factory, bool bLoadable = true)
+    inline Identifier* registerClass(const std::string& name, ClassFactory<T>* factory, bool bLoadable = true)
+    {
         return registerClass<T>(name, static_cast<Factory*>(factory), bLoadable);
 …
      */
     template <class T>
+    inline Identifier& registerClass(const std::string& name, Factory* factory, bool bLoadable = true)
+    {
+        orxout(verbose, context::misc::factory) << "Create entry for " << name << " in Factory." << endl;
+        Identifier* identifier = ClassIdentifier<T>::getIdentifier(name);
+        identifier->setFactory(factory);
+        identifier->setLoadable(bLoadable);
+        return *identifier;
+    inline Identifier* registerClass(const std::string& name, Factory* factory, bool bLoadable = true)
+    {
+        return new ClassIdentifier<T>(name, factory, bLoadable);
+    }
 …
         return ClassIdentifier<T>::getIdentifier();
+    }
+    /**
+     * The static initializer stores the parent classes of this identifier. The corresponding identifiers are later loaded. This prevents identifiers from
+     * being used before they are completely initialized.
+     */
+    class _CoreExport StaticallyInitializedIdentifier : public StaticallyInitializedInstance
+    {
+        template <class T>
+        struct InheritsFromClass : public Identifier::InheritsFrom
+        {
+            virtual Identifier* getParent() const { return Class(T); }
+        };
+        public:
+            StaticallyInitializedIdentifier(Identifier* identifier)
+                : StaticallyInitializedInstance(StaticInitialization::IDENTIFIER)
+                , identifier_(identifier)
+            {}
+            ~StaticallyInitializedIdentifier() { delete identifier_; }
+            virtual void load()
+            {
+                IdentifierManager::getInstance().addIdentifier(this->identifier_);
+            }
+            virtual void unload()
+            {
+                IdentifierManager::getInstance().removeIdentifier(this->identifier_);
+            }
+            inline Identifier& getIdentifier()
+                { return *this->identifier_; }
+            template <class T>
+            inline StaticallyInitializedIdentifier& inheritsFrom()
+                { this->identifier_->inheritsFrom(new InheritsFromClass<T>()); return *this; }
+            inline StaticallyInitializedIdentifier& virtualBase()
+                { this->identifier_->setVirtualBase(true); return *this; }
+        private:
+            Identifier* identifier_;
+    };
+    typedef StaticallyInitializedIdentifier SI_I;
+}

code/trunk/src/libraries/core/CorePrereqs.h

-                      r9978
+                      r10624
 namespace orxonox
+{
+    namespace ScopeID
+    {
+        typedef int Value;
+        //!A list of available scopes for the Scope template.
+        static const Value ROOT = 1;
+        static const Value GRAPHICS = 2;
+    }
+    namespace StaticInitialization
+    {
+        typedef int Type;
+        static const Type STATIC_INITIALIZATION_HANDLER = 1;
+        static const Type IDENTIFIER = 2;
+        static const Type SCOPED_SINGLETON_WRAPPER = 3;
+        static const Type COMMAND_LINE_ARGUMENT = 4;
+        static const Type CONSOLE_COMMAND = 5;
+    }
     namespace XMLPort
+    {
 …
     T orxonox_cast(U*);
+    class ApplicationPaths;
     class BaseObject;
     template <class T>
 …
     class ConfigFileSection;
     class Configurable;
+    class ConfigurablePaths;
     class ConfigValueContainer;
     class Context;
     class Core;
+    class CoreConfig;
+    class CoreStaticInitializationHandler;
     class Destroyable;
+    class DestroyLaterManager;
     class DestructionListener;
     class DynLib;
 …
     class Factory;
     class Game;
+    class GameConfig;
     class GameState;
     struct GameStateInfo;
 …
     class Language;
     class Listable;
+    class Loader;
     class LuaFunctor;
     class LuaState;
     class MemoryArchive;
     class MemoryArchiveFactory;
+    class ModuleInstance;
     class Namespace;
     class NamespaceNode;
 …
     class OrxonoxClass;
     class OrxonoxInterface;
+    class PathConfig;
+    class Plugin;
+    class PluginManager;
+    class PluginReference;
     struct ResourceInfo;
+    template <ScopeID::Value>
+    class Scope;
+    class ScopeManager;
+    class ScopedSingletonWrapper;
     class SettingsConfigFile;
+    template <class T>
+    class SmartPtr;
+    class StaticallyInitializedInstance;
+    class StaticInitializationHandler;
+    class StaticInitializationManager;
+    template <class T>
+    class StrongPtr;
     template <class T>
     class SubclassIdentifier;
 …
     class Thread;
     class ThreadPool;
+    class UpdateListener;
     class ViewportEventListener;
     template <class T>
 …
     class CommandEvaluation;
     class ConsoleCommand;
+    class ConsoleCommandManager;
     class Executor;
     template <class T>

code/trunk/src/libraries/core/GUIManager.cc

-                      r10279
+                      r10624
 #include "GraphicsManager.h"
 #include "LuaState.h"
 #include "PathConfig.h"
+#include "ConfigurablePaths.h"
 #include "Resource.h"
 #include "command/ConsoleCommand.h"
+#include "command/ConsoleCommandIncludes.h"
 #include "input/InputManager.h"
 #include "input/InputState.h"
 …
     SetConsoleCommand("toggleGUI", &GUIManager::toggleGUI).defaultValue(1, false).defaultValue(2, false);
+    RegisterAbstractClass(GUIManager).inheritsFrom<WindowEventListener>();
     /**
     @brief
 …
         // Create our own logger to specify the filepath
         std::auto_ptr<CEGUILogger> ceguiLogger(new CEGUILogger());
         ceguiLogger->setLogFilename(PathConfig::getLogPathString() + "cegui.log");
+        ceguiLogger->setLogFilename(ConfigurablePaths::getLogPathString() + "cegui.log");
         ceguiLogger->setLoggingLevel(static_cast<CEGUI::LoggingLevel>(this->outputLevelCeguiLog_));
         this->ceguiLogger_ = ceguiLogger.release();
 …
     /*static*/ bool GUIManager::inDevMode()
+    {
          return Core::getInstance().inDevMode();
+         return Core::getInstance().getConfig()->inDevMode();
+    }

code/trunk/src/libraries/core/Game.cc

-                      r9667
+                      r10624
 #include "util/SubString.h"
 #include "Core.h"
+#include "CoreIncludes.h"
+#include "config/CommandLineParser.h"
+#include "config/ConfigValueIncludes.h"
+#include "commandline/CommandLineParser.h"
+#include "GameConfig.h"
 #include "GameMode.h"
 #include "GameState.h"
 #include "GraphicsManager.h"
 #include "GUIManager.h"
 #include "command/ConsoleCommand.h"
+#include "command/ConsoleCommandIncludes.h"
 namespace orxonox
 …
         , bChangingState_(false)
         , bAbort_(false)
+        , config_(NULL)
         , destructionHelper_(this)
+    {
 …
         orxout(internal_info) << "creating Core object:" << endl;
         this->core_ = new Core(cmdLine);
+        this->core_->loadModules();
         // Do this after the Core creation!
+        RegisterObject(Game);
+        this->setConfigValues();
+        this->config_ = new GameConfig();
         // After the core has been created, we can safely instantiate the GameStates that don't require graphics
 …
         orxout(internal_status) << "destroying Game object..." << endl;
-        // Remove us from the object lists again to avoid problems when destroying them
-        this->unregisterObject();
         assert(loadedStates_.size() <= 1); // Just empty root GameState
         // Destroy all GameStates (shared_ptrs take care of actual destruction)
 …
         GameStateFactory::getFactories().clear();
+        safeObjectDelete(&config_);
+        if (this->core_)
+            this->core_->unloadModules();
         safeObjectDelete(&core_);
         safeObjectDelete(&gameClock_);
         orxout(internal_status) << "finished destroying Game object..." << endl;
+    }
-    void Game::setConfigValues()
+    {
-        SetConfigValue(statisticsRefreshCycle_, 250000)
-            .description("Sets the time in microseconds interval at which average fps, etc. get updated.");
-        SetConfigValue(statisticsAvgLength_, 1000000)
-            .description("Sets the time in microseconds interval at which average fps, etc. gets calculated.");
-        SetConfigValueExternal(fpsLimit_, "GraphicsSettings", "fpsLimit", 50)
-            .description("Sets the desired frame rate (0 for no limit).");
+    }
 …
             // Limit frame rate
             static bool hasVSync = GameMode::showsGraphics() && GraphicsManager::getInstance().hasVSyncEnabled(); // can be static since changes of VSync currently require a restart
             if (this->fpsLimit_ > 0 && !hasVSync)
+            if (this->config_->getFpsLimit() > 0 && !hasVSync)
                 this->updateFPSLimiter();
+        }
 …
         this->statisticsTickTimes_.back().tickLength += (uint32_t)(currentRealTime - currentTime);
         this->periodTickTime_ += (uint32_t)(currentRealTime - currentTime);
         if (this->periodTime_ > this->statisticsRefreshCycle_)
+        if (this->periodTime_ > this->config_->getStatisticsRefreshCycle())
+        {
             std::list<StatisticsTickInfo>::iterator it = this->statisticsTickTimes_.begin();
             assert(it != this->statisticsTickTimes_.end());
             int64_t lastTime = currentTime - this->statisticsAvgLength_;
+            int64_t lastTime = currentTime - this->config_->getStatisticsAvgLength();
             if (static_cast<int64_t>(it->tickTime) < lastTime)
+            {
 …
             this->avgTickTime_ = static_cast<float>(this->periodTickTime_) / framesPerPeriod / 1000.0f;
             this->periodTime_ -= this->statisticsRefreshCycle_;
+            this->periodTime_ -= this->config_->getStatisticsRefreshCycle();
+        }
+    }
 …
     void Game::updateFPSLimiter()
+    {
         uint64_t nextTime = gameClock_->getMicroseconds() - excessSleepTime_ + static_cast<uint32_t>(1000000.0f / fpsLimit_);
+        uint64_t nextTime = gameClock_->getMicroseconds() - excessSleepTime_ + static_cast<uint32_t>(1000000.0f / this->config_->getFpsLimit());
         uint64_t currentRealTime = gameClock_->getRealMicroseconds();
         while (currentRealTime < nextTime - minimumSleepTime_)
 …
             core_->loadGraphics();
             Loki::ScopeGuard graphicsUnloader = Loki::MakeObjGuard(*this, &Game::unloadGraphics);
+            Loki::ScopeGuard graphicsUnloader = Loki::MakeObjGuard(*this, &Game::unloadGraphics, true);
             // Construct all the GameStates that require graphics
 …
+    }
     void Game::unloadGraphics()
+    void Game::unloadGraphics(bool loadGraphicsManagerWithoutRenderer)
+    {
         if (GameMode::showsGraphics())
 …
+            }
             core_->unloadGraphics();
+            core_->unloadGraphics(loadGraphicsManagerWithoutRenderer);
+        }
+    }
 …
         // If state requires graphics, load it
         Loki::ScopeGuard graphicsUnloader = Loki::MakeObjGuard(*this, &Game::unloadGraphics);
+        Loki::ScopeGuard graphicsUnloader = Loki::MakeObjGuard(*this, &Game::unloadGraphics, true);
         if (gameStateDeclarations_s[name].bGraphicsMode && !GameMode::showsGraphics())
             this->loadGraphics();
 …
+        }
         // Check if graphics is still required
+        if (!bAbort_)
+        {
+            bool graphicsRequired = false;
+            for (unsigned i = 0; i < loadedStates_.size(); ++i)
+                graphicsRequired |= loadedStates_[i]->getInfo().bGraphicsMode;
+            if (!graphicsRequired)
+                this->unloadGraphics();
+        }
+        bool graphicsRequired = false;
+        for (unsigned i = 0; i < loadedStates_.size(); ++i)
+            graphicsRequired |= loadedStates_[i]->getInfo().bGraphicsMode;
+        if (!graphicsRequired)
+            this->unloadGraphics(!this->bAbort_); // if abort is false, that means the game is still running while unloading graphics. in this case we load a graphics manager without renderer (to keep all necessary ogre instances alive)
         this->bChangingState_ = false;
+    }

code/trunk/src/libraries/core/Game.h

-                      r9667
+                      r10624
 #include "util/DestructionHelper.h"
 #include "util/Singleton.h"
-#include "config/Configurable.h"
 /**
 …
     class _CoreExport Game
 // tolua_end
         : public Singleton<Game>, public Configurable
+        : public Singleton<Game>
     { // tolua_export
         friend class Singleton<Game>;
 …
         /// Destructor that also executes when object fails to construct
         void destroy();
-        void setConfigValues();
         void setStateHierarchy(const std::string& str);
 …
         void loadGraphics();
         void unloadGraphics();
+        void unloadGraphics(bool loadGraphicsManagerWithoutRenderer = true);
         void parseStates(std::vector<std::pair<std::string, int> >::const_iterator& it, shared_ptr<GameStateTreeNode> currentNode);
 …
         unsigned int                       minimumSleepTime_;
+        // config values
+        unsigned int                       statisticsRefreshCycle_;
+        unsigned int                       statisticsAvgLength_;
+        unsigned int                       fpsLimit_;
+        /// Helper object that stores the config values
+        GameConfig*                        config_;
         /// Helper object that executes the surrogate destructor destroy()

code/trunk/src/libraries/core/GraphicsManager.cc

-                      r10295
+                      r10624
 #include "GUIManager.h"
 #include "Loader.h"
+#include "PathConfig.h"
+#include "ApplicationPaths.h"
+#include "ConfigurablePaths.h"
 #include "ViewportEventListener.h"
 #include "WindowEventListener.h"
 #include "XMLFile.h"
 #include "command/ConsoleCommand.h"
+#include "command/ConsoleCommandIncludes.h"
 #include "input/InputManager.h"
 …
     GraphicsManager* GraphicsManager::singletonPtr_s = 0;
+    RegisterAbstractClass(GraphicsManager).inheritsFrom<Configurable>();
     GraphicsManager::GraphicsManager(bool bLoadRenderer)
         : ogreWindowEventListener_(new OgreWindowEventListener())
 …
         // At first, add the root paths of the data directories as resource locations
         Ogre::ResourceGroupManager::getSingleton().addResourceLocation(PathConfig::getDataPathString(), "FileSystem");
+        Ogre::ResourceGroupManager::getSingleton().addResourceLocation(ConfigurablePaths::getDataPathString(), "FileSystem");
         // Load resources
         resources_.reset(new XMLFile("DefaultResources.oxr"));
         resources_->setLuaSupport(false);
         Loader::open(resources_.get(), ClassTreeMask(), false);
+        Loader::getInstance().load(resources_.get(), ClassTreeMask(), false);
         // Only for runs in the build directory (not installed)
         if (PathConfig::buildDirectoryRun())
             Ogre::ResourceGroupManager::getSingleton().addResourceLocation(PathConfig::getExternalDataPathString(), "FileSystem");
+        if (ApplicationPaths::buildDirectoryRun())
+            Ogre::ResourceGroupManager::getSingleton().addResourceLocation(ConfigurablePaths::getExternalDataPathString(), "FileSystem");
         extResources_.reset(new XMLFile("resources.oxr"));
         extResources_->setLuaSupport(false);
         Loader::open(extResources_.get(), ClassTreeMask(), false);
+        Loader::getInstance().load(extResources_.get(), ClassTreeMask(), false);
         if (bLoadRenderer)
 …
+    {
         orxout(internal_status) << "destroying GraphicsManager..." << endl;
-        Loader::unload(debugOverlay_.get());
         Ogre::WindowEventUtilities::removeWindowEventListener(renderWindow_, ogreWindowEventListener_);
 …
         // Undeclare the resources
         Loader::unload(resources_.get());
         Loader::unload(extResources_.get());
+        Loader::getInstance().unload(resources_.get());
+        Loader::getInstance().unload(extResources_.get());
         safeObjectDelete(&ogreRoot_);
 …
+        }
         boost::filesystem::path ogreConfigFilepath(PathConfig::getConfigPath() / this->ogreConfigFile_);
         boost::filesystem::path ogreLogFilepath(PathConfig::getLogPath() / this->ogreLogFile_);
+        boost::filesystem::path ogreConfigFilepath(ConfigurablePaths::getConfigPath() / this->ogreConfigFile_);
+        boost::filesystem::path ogreLogFilepath(ConfigurablePaths::getLogPath() / this->ogreLogFile_);
         // create a new logManager
 …
         std::string pluginPath = specialConfig::ogrePluginsDirectory;
 #ifdef DEPENDENCY_PACKAGE_ENABLE
         if (!PathConfig::buildDirectoryRun())
+        if (!ApplicationPaths::buildDirectoryRun())
+        {
 #  if defined(ORXONOX_PLATFORM_WINDOWS)
             pluginPath = PathConfig::getExecutablePathString();
+            pluginPath = ApplicationPaths::getExecutablePathString();
 #  elif defined(ORXONOX_PLATFORM_APPLE)
             // TODO: Where are the plugins being installed to?
             pluginPath = PathConfig::getExecutablePathString();
+            pluginPath = ApplicationPaths::getExecutablePathString();
 #  endif
+        }
 …
         orxout(internal_info) << "GraphicsManager: Configuring Renderer" << endl;
         bool updatedConfig = Core::getInstance().getOgreConfigTimestamp() > Core::getInstance().getLastLevelTimestamp();
+        bool updatedConfig = Core::getInstance().getConfig()->getOgreConfigTimestamp() > Core::getInstance().getConfig()->getLastLevelTimestamp();
         if (updatedConfig)
             orxout(user_info)<< "Ogre config file has changed, but no level was started since then. Displaying config dialogue again to verify the changes." << endl;
 …
                 ThrowException(InitialisationFailed, "OGRE graphics configuration dialogue canceled.");
             else
                 Core::getInstance().updateOgreConfigTimestamp();
+                Core::getInstance().getConfig()->updateOgreConfigTimestamp();
+        }
 …
         orxout(internal_info) << "Loading Debug Overlay..." << endl;
         debugOverlay_.reset(new XMLFile("debug.oxo"));
+        Loader::open(debugOverlay_.get(), ClassTreeMask(), false);
+        Loader::getInstance().load(debugOverlay_.get(), ClassTreeMask(), false);
+    }
+    void GraphicsManager::unloadDebugOverlay()
+    {
+        Loader::getInstance().unload(debugOverlay_.get());
+    }
 …
             GraphicsManager::getInstance().getRenderWindow()->setFullscreen(fullscreen, width, height);
             this->ogreRoot_->saveConfig();
             Core::getInstance().updateOgreConfigTimestamp();
+            Core::getInstance().getConfig()->updateOgreConfigTimestamp();
             // Also reload the input devices
             InputManager::getInstance().reload();
 …
             //this->ogreRoot_->getRenderSystem()->reinitialise(); // can't use this that easily, because it recreates the render window, invalidating renderWindow_
             this->ogreRoot_->saveConfig();
             Core::getInstance().updateOgreConfigTimestamp();
+            Core::getInstance().getConfig()->updateOgreConfigTimestamp();
+        }
 …
             //this->ogreRoot_->getRenderSystem()->reinitialise(); // can't use this that easily, because it recreates the render window, invalidating renderWindow_
             this->ogreRoot_->saveConfig();
             Core::getInstance().updateOgreConfigTimestamp();
+            Core::getInstance().getConfig()->updateOgreConfigTimestamp();
+        }
 …
+    {
         assert(this->renderWindow_);
         this->renderWindow_->writeContentsToTimestampedFile(PathConfig::getLogPathString() + "screenShot_", ".png");
+        this->renderWindow_->writeContentsToTimestampedFile(ConfigurablePaths::getLogPathString() + "screenShot_", ".png");
+    }
+}

code/trunk/src/libraries/core/GraphicsManager.h

r9675	r10624
95	95	void upgradeToGraphics();
96	96	void loadDebugOverlay();
	97	void unloadDebugOverlay();
97	98	bool rendererLoaded() const { return renderWindow_ != NULL; }
98	99

code/trunk/src/libraries/core/Language.cc

-                      r8858
+                      r10624
 #include "util/Output.h"
 #include "util/StringUtils.h"
+#include "Core.h"
+#include "PathConfig.h"
+#include "ConfigurablePaths.h"
 namespace orxonox
 …
         orxout(internal_info, context::language) << "Read default language file." << endl;
         const std::string& filepath = PathConfig::getConfigPathString() + getFilename(this->defaultLanguage_);
+        const std::string& filepath = ConfigurablePaths::getConfigPathString() + getFilename(this->defaultLanguage_);
         // This creates the file if it's not existing
 …
     /**
         @brief Reads the language file of the configured language and assigns the localisation to the corresponding LanguageEntry object.
+    */
+    void Language::readTranslatedLanguageFile()
+    {
+        orxout(internal_info, context::language) << "Read translated language file (" << Core::getInstance().getLanguage() << ")." << endl;
+        const std::string& filepath = PathConfig::getConfigPathString() + getFilename(Core::getInstance().getLanguage());
+        @return Returns false if the language file couldn't be found.
+    */
+    bool Language::readTranslatedLanguageFile(const std::string& language)
+    {
+        orxout(internal_info, context::language) << "Read translated language file (" << language << ")." << endl;
+        const std::string& filepath = ConfigurablePaths::getConfigPathString() + getFilename(language);
         // Open the file
 …
+        {
             orxout(internal_error, context::language) << "An error occurred in Language.cc:" << endl;
+            orxout(internal_error, context::language) << "Couldn't open file " << getFilename(Core::getInstance().getLanguage()) << " to read the translated language entries!" << endl;
+            Core::getInstance().resetLanguage();
+            orxout(internal_info, context::language) << "Reset language to " << this->defaultLanguage_ << '.' << endl;
+            return;
+            orxout(internal_error, context::language) << "Couldn't open file " << getFilename(language) << " to read the translated language entries!" << endl;
+            return false;
+        }
 …
                 else
+                {
                     orxout(internal_warning, context::language) << "Invalid language entry \"" << lineString << "\" in " << getFilename(Core::getInstance().getLanguage()) << endl;
+                    orxout(internal_warning, context::language) << "Invalid language entry \"" << lineString << "\" in " << getFilename(language) << endl;
+                }
+            }
 …
         file.close();
+        return true;
+    }
 …
         orxout(verbose, context::language) << "Write default language file." << endl;
         const std::string& filepath = PathConfig::getConfigPathString() + getFilename(this->defaultLanguage_);
+        const std::string& filepath = ConfigurablePaths::getConfigPathString() + getFilename(this->defaultLanguage_);
         // Open the file

code/trunk/src/libraries/core/Language.h

-                      r8858
+                      r10624
+    {
         friend class Singleton<Language>;
         friend class Core;
+        friend class CoreConfig;
         public:
 …
             void readDefaultLanguageFile();
             void readTranslatedLanguageFile();
+            bool readTranslatedLanguageFile(const std::string& language);
             void writeDefaultLanguageFile() const;
             static std::string getFilename(const std::string& language);

code/trunk/src/libraries/core/Loader.cc

-                      r10278
+                      r10624
 namespace orxonox
+{
+    std::vector<std::pair<const XMLFile*, ClassTreeMask> > Loader::files_s;
+    ClassTreeMask Loader::currentMask_s;
+    bool Loader::open(const XMLFile* file, const ClassTreeMask& mask, bool bVerbose)
+    {
+        Loader::add(file, mask);
+        return Loader::load(file, mask, bVerbose);
+    }
+    void Loader::close()
+    {
+        Loader::unload();
+        Loader::files_s.clear();
+    }
+    void Loader::close(const XMLFile* file)
+    {
+        Loader::unload(file);
+        Loader::remove(file);
+    }
+    void Loader::add(const XMLFile* file, const ClassTreeMask& mask)
+    {
+        if (!file)
+            return;
+        Loader::files_s.insert(Loader::files_s.end(), std::pair<const XMLFile*, ClassTreeMask>(file, mask));
+    }
+    void Loader::remove(const XMLFile* file)
+    {
+        if (!file)
+            return;
+        for (std::vector<std::pair<const XMLFile*, ClassTreeMask> >::iterator it = Loader::files_s.begin(); it != Loader::files_s.end(); ++it)
+        {
+            if (it->first == file)
+            {
+                Loader::files_s.erase(it);
+                break;
+            }
+        }
+    }
+    /**
+    @brief
+        Loads all opened files, while conforming to the restrictions given by the input ClassTreeMask.
+    @param mask
+        A ClassTreeMask, which defines which types of classes are loaded and which aren't.
+    @param bVerbose
+        Whether the loader is verbose (prints its progress in a low output level) or not.
+    @return
+        Returns true if successful.
+    */
+    bool Loader::load(const ClassTreeMask& mask, bool bVerbose)
+    {
+        bool success = true;
+        for (std::vector<std::pair<const XMLFile*, ClassTreeMask> >::iterator it = Loader::files_s.begin(); it != Loader::files_s.end(); ++it)
+            if (!Loader::load(it->first, it->second * mask, bVerbose))
+                success = false;
+        return success;
+    }
+    void Loader::unload(const ClassTreeMask& mask)
+    {
+        for (ObjectList<BaseObject>::iterator it = ObjectList<BaseObject>::begin(); it != ObjectList<BaseObject>::end(); )
+        {
+            if (mask.isIncluded(it->getIdentifier()))
+                (it++)->destroy();
+            else
+                ++it;
+        }
+    }
+    /**
+    @brief
+        Reloads all opened files, while conforming to the restrictions given by the input ClassTreeMask.
+    @param mask
+        A ClassTreeMask, which defines which types of classes are reloaded and which aren't.
+    @param bVerbose
+        Whether the loader is verbose (prints its progress in a low output level) or not.
+    @return
+        Returns true if successful.
+    */
+    bool Loader::reload(const ClassTreeMask& mask, bool bVerbose)
+    {
+        Loader::unload(mask);
+        return Loader::load(mask, bVerbose);
+    }
+    Loader* Loader::singletonPtr_s = 0;
     /**
 …
             return false;
         Loader::currentMask_s = file->getMask() * mask;
+        this->currentMask_ = file->getMask() * mask;
         std::string xmlInput;
 …
                 // start of the program.
                 // Assumption: the LevelInfo tag does not use Lua scripting
                 xmlInput = removeLuaTags(xmlInput);
+                xmlInput = Loader::removeLuaTags(xmlInput);
+            }
+        }
 …
+            {
                 orxout(user_info) << "Start loading " << file->getFilename() << "..." << endl;
                 orxout(internal_info, context::loader) << "Mask: " << Loader::currentMask_s << endl;
+                orxout(internal_info, context::loader) << "Mask: " << this->currentMask_ << endl;
+            }
             else
+            {
                 orxout(verbose, context::loader) << "Start loading " << file->getFilename() << "..." << endl;
                 orxout(verbose_more, context::loader) << "Mask: " << Loader::currentMask_s << endl;
+                orxout(verbose_more, context::loader) << "Mask: " << this->currentMask_ << endl;
+            }
 …
             rootNamespace->setLoaderIndentation("    ");
             rootNamespace->setFile(file);
-            rootNamespace->setNamespace(rootNamespace);
             rootNamespace->setRoot(true);
             rootNamespace->XMLPort(rootElement, XMLPort::LoadObject);
 …
                 ++it;
+        }
+    }
-    /**
-    @brief
-        Reloads the input file, while conforming to the restrictions given by the input ClassTreeMask.
-    @param file
-        The file to be reloaded.
-    @param mask
-        A ClassTreeMask, which defines which types of classes are reloaded and which aren't.
-    @param bVerbose
-        Whether the loader is verbose (prints its progress in a low output level) or not.
-    @return
-        Returns true if successful.
-    */
-    bool Loader::reload(const XMLFile* file, const ClassTreeMask& mask, bool bVerbose)
+    {
-        Loader::unload(file, mask);
-        return Loader::load(file, mask, bVerbose);
+    }

code/trunk/src/libraries/core/Loader.h

-                      r8858
+                      r10624
 #include <map>
 #include <vector>
+#include "util/Singleton.h"
 #include "ClassTreeMask.h"
 namespace orxonox
+{
     class _CoreExport Loader
+    class _CoreExport Loader : public Singleton<Loader>
+    {
+        friend class Singleton<Loader>;
         public:
+            static bool open(const XMLFile* file, const ClassTreeMask& mask = ClassTreeMask(), bool bVerbose = true);
+            static void close();
+            static void close(const XMLFile* file);
+            static void add(const XMLFile* file, const ClassTreeMask& mask = ClassTreeMask());
+            static void remove(const XMLFile* file);
+            static bool load(const ClassTreeMask& mask = ClassTreeMask(), bool bVerbose = true);
+            static void unload(const ClassTreeMask& mask = ClassTreeMask());
+            static bool reload(const ClassTreeMask& mask = ClassTreeMask(), bool bVerbose = true);
+            static bool load(const XMLFile* file, const ClassTreeMask& mask = ClassTreeMask(),
+                             bool bVerbose = true, bool bRemoveLuaTags = false);
+            static void unload(const XMLFile* file, const ClassTreeMask& mask = ClassTreeMask());
+            static bool reload(const XMLFile* file, const ClassTreeMask& mask = ClassTreeMask(), bool bVerbose = true);
+            bool load(const XMLFile* file, const ClassTreeMask& mask = ClassTreeMask(),
+                      bool bVerbose = true, bool bRemoveLuaTags = false);
+            void unload(const XMLFile* file, const ClassTreeMask& mask = ClassTreeMask());
             static std::string replaceLuaTags(const std::string& text);
             static std::string removeLuaTags(const std::string& text);
             static ClassTreeMask currentMask_s;
+            ClassTreeMask currentMask_;
         private:
             static bool getLuaTags(const std::string& text, std::map<size_t, bool>& luaTags);
+            static std::vector<std::pair<const XMLFile*, ClassTreeMask> > files_s;
+            std::vector<std::pair<const XMLFile*, ClassTreeMask> > files_;
+            static Loader* singletonPtr_s;
     };
+}

code/trunk/src/libraries/core/Namespace.cc

r10298	r10624
47	47	RegisterObject(Namespace);
48	48
49		this->setNamespace(~~SmartPtr<Namespace>(this, false));~~
	49	this->setNamespace(WeakPtr<Namespace>(this)); // store a weak-pointer to itself (a strong-pointer would create a recursive dependency)
50	50	}
51	51
…	…
105	105	void Namespace::loadObjects(BaseObject* object)
106	106	{
107		~~object->setNamespace(this);~~
108	107	}
109	108

code/trunk/src/libraries/core/ViewportEventListener.cc

r9667	r10624
32	32	namespace orxonox
33	33	{
34		RegisterAbstractClass(ViewportEventListener).inheritsFrom~~(Class(Listable)~~);
	34	RegisterAbstractClass(ViewportEventListener).inheritsFrom<Listable>();
35	35
36	36	ViewportEventListener::ViewportEventListener()

code/trunk/src/libraries/core/WindowEventListener.cc

r9667	r10624
35	35	unsigned int WindowEventListener::windowHeight_s = 0;
36	36
37		RegisterAbstractClass(WindowEventListener).inheritsFrom~~(Class(Listable)~~);
	37	RegisterAbstractClass(WindowEventListener).inheritsFrom<Listable>();
38	38
39	39	WindowEventListener::WindowEventListener()

code/trunk/src/libraries/core/XMLNameListener.cc

r9667	r10624
32	32	namespace orxonox
33	33	{
34		RegisterAbstractClass(XMLNameListener).inheritsFrom~~(Class(Listable)~~);
	34	RegisterAbstractClass(XMLNameListener).inheritsFrom<Listable>();
35	35
36	36	XMLNameListener::XMLNameListener()

code/trunk/src/libraries/core/XMLPort.cc

r9667	r10624
40	40	bool XMLPortObjectContainer::identifierIsIncludedInLoaderMask(const Identifier* identifier)
41	41	{
42		return ((!this->bApplyLoaderMask_) \|\| identifier->isA(ClassIdentifier<Namespace>::getIdentifier()) \|\| Loader::~~currentMask_s~~.isIncluded(identifier));
	42	return ((!this->bApplyLoaderMask_) \|\| identifier->isA(ClassIdentifier<Namespace>::getIdentifier()) \|\| Loader::getInstance().currentMask_.isIncluded(identifier));
43	43	}
44	44

code/trunk/src/libraries/core/class/Identifiable.cc

r9667	r10624
41	41	namespace orxonox
42	42	{
43		RegisterClassNoArgs(Identifiable);
	43	RegisterClassNoArgs(Identifiable).virtualBase();
44	44
45	45	/**

code/trunk/src/libraries/core/class/Identifier.cc

-                      r9667
+                      r10624
 namespace orxonox
+{
+    bool Identifier::initConfigValues_s = true;
     // ###############################
     // ###       Identifier        ###
 …
         @brief Constructor: No factory, no object created, new ObjectList and a unique networkID.
     */
+    Identifier::Identifier()
+        : classID_(IdentifierManager::getInstance().getUniqueClassId())
+    {
+        this->factory_ = 0;
+    Identifier::Identifier(const std::string& name, Factory* factory, bool bLoadable)
+    {
+        orxout(verbose, context::identifier) << "Create identifier for " << name << endl;
+        static unsigned int classIDCounter = 0;
+        this->classID_ = classIDCounter++;
+        this->name_ = name;
+        this->factory_ = factory;
+        this->bLoadable_ = bLoadable;
         this->bInitialized_ = false;
         this->bLoadable_ = false;
+        this->bIsVirtualBase_ = false;
         this->bHasConfigValues_ = false;
 …
             delete this->factory_;
+        for (std::list<const InheritsFrom*>::const_iterator it = this->manualDirectParents_.begin(); it != this->manualDirectParents_.end(); ++it)
+            delete (*it);
+        // erase this Identifier from all related identifiers
+        for (std::list<const Identifier*>::const_iterator it = this->parents_.begin(); it != this->parents_.end(); ++it)
+            const_cast<Identifier*>(*it)->children_.erase(this);
+        for (std::list<const Identifier*>::const_iterator it = this->directParents_.begin(); it != this->directParents_.end(); ++it)
+            const_cast<Identifier*>(*it)->directChildren_.erase(this);
+        for (std::set<const Identifier*>::const_iterator it = this->children_.begin(); it != this->children_.end(); ++it)
+            const_cast<Identifier*>(*it)->parents_.remove(this);
+        for (std::set<const Identifier*>::const_iterator it = this->directChildren_.begin(); it != this->directChildren_.end(); ++it)
+            const_cast<Identifier*>(*it)->directParents_.remove(this);
         for (std::map<std::string, ConfigValueContainer*>::iterator it = this->configValues_.begin(); it != this->configValues_.end(); ++it)
             delete (it->second);
 …
         for (std::map<std::string, XMLPortObjectContainer*>::iterator it = this->xmlportObjectContainers_.begin(); it != this->xmlportObjectContainers_.end(); ++it)
             delete (it->second);
+    }
-    /**
-        @brief Sets the name of the class.
-    */
-    void Identifier::setName(const std::string& name)
+    {
-        if (name != this->name_)
+        {
-            this->name_ = name;
-            IdentifierManager::getInstance().addIdentifierToLookupMaps(this);
+        }
+    }
-    void Identifier::setFactory(Factory* factory)
+    {
-        if (this->factory_)
-            delete this->factory_;
-        this->factory_ = factory;
+    }
 …
+    {
         this->networkID_ = id;
         IdentifierManager::getInstance().addIdentifierToLookupMaps(this);
+        IdentifierManager::getInstance().addIdentifier(this);    // add with new id
+    }
 …
      * @brief Used to define the direct parents of an Identifier of an abstract class.
      */
     Identifier& Identifier::inheritsFrom(Identifier* directParent)
+    {
         if (this->parents_.empty())
             this->directParents_.insert(directParent);
         else
             orxout(internal_error) << "Trying to add " << directParent->getName() << " as a direct parent of " << this->getName() << " after the latter was already initialized" << endl;
+    Identifier& Identifier::inheritsFrom(InheritsFrom* directParent)
+    {
+        if (this->directParents_.empty())
+            this->manualDirectParents_.push_back(directParent);
+        else
+            orxout(internal_error) << "Trying to manually add direct parent of " << this->getName() << " after the latter was already initialized" << endl;
         return *this;
 …
     /**
      * @brief Initializes the parents of this Identifier while creating the class hierarchy.
      * @param identifiers All identifiers that were used to create an instance of this class (including this identifier itself)
      */
     void Identifier::initializeParents(const std::set<const Identifier*>& identifiers)
+     * @param initializationTrace All identifiers that were recorded while creating an instance of this class (including nested classes and this identifier itself)
+     */
+    void Identifier::initializeParents(const std::list<const Identifier*>& initializationTrace)
+    {
         if (!IdentifierManager::getInstance().isCreatingHierarchy())
 …
+        }
+        for (std::set<const Identifier*>::const_iterator it = identifiers.begin(); it != identifiers.end(); ++it)
+            if (*it != this)
+                this->parents_.insert(*it);
+    }
+    /**
+     * @brief Initializes the direct parents of this Identifier while creating the class hierarchy. This is only intended for abstract classes.
+     */
+    void Identifier::initializeDirectParentsOfAbstractClass()
+        if (this->directParents_.empty())
+        {
+            for (std::list<const Identifier*>::const_iterator it = initializationTrace.begin(); it != initializationTrace.end(); ++it)
+                if (*it != this)
+                    this->parents_.push_back(*it);
+        }
+        else
+            orxout(internal_error) << "Trying to add parents to " << this->getName() << " after it was already initialized with manual calls to inheritsFrom<Class>()." << endl;
+    }
+    /**
+     * @brief Finishes the initialization of this Identifier after creating the class hierarchy by wiring the (direct) parent/child references correctly.
+     */
+    void Identifier::finishInitialization()
+    {
         if (!IdentifierManager::getInstance().isCreatingHierarchy())
+        {
             orxout(internal_warning) << "Identifier::initializeDirectParentsOfAbstractClass() created outside of class hierarchy creation" << endl;
+            orxout(internal_warning) << "Identifier::finishInitialization() created outside of class hierarchy creation" << endl;
             return;
+        }
+        // only Identifiable is allowed to have no parents (even tough it's currently not abstract)
+        if (this->directParents_.empty() && !this->isExactlyA(Class(Identifiable)))
+        {
+            orxout(internal_error) << "Identifier " << this->getName() << " / " << this->getTypeidName() << " is marked as abstract but has no direct parents defined" << endl;
+        if (this->isInitialized())
+            return;
+        if (!this->parents_.empty())
+        {
+            // parents defined -> this class was initialized by creating a sample instance and recording the trace of identifiers
+            // initialize all parents
+            for (std::list<const Identifier*>::const_iterator it = this->parents_.begin(); it != this->parents_.end(); ++it)
+                const_cast<Identifier*>(*it)->finishInitialization(); // initialize parent
+            // parents of parents are no direct parents of this identifier
+            this->directParents_ = this->parents_;
+            for (std::list<const Identifier*>::const_iterator it_parent = this->parents_.begin(); it_parent != this->parents_.end(); ++it_parent)
+                for (std::list<const Identifier*>::const_iterator it_parent_parent = const_cast<Identifier*>(*it_parent)->parents_.begin(); it_parent_parent != const_cast<Identifier*>(*it_parent)->parents_.end(); ++it_parent_parent)
+                    this->directParents_.remove(*it_parent_parent);
+            this->verifyIdentifierTrace();
+        }
+        else if (!this->manualDirectParents_.empty())
+        {
+            // no parents defined -> this class was manually initialized by calling inheritsFrom<Class>()
+            // initialize all direct parents
+            for (std::list<const InheritsFrom*>::const_iterator it = this->manualDirectParents_.begin(); it != this->manualDirectParents_.end(); ++it)
+            {
+                Identifier* directParent = (*it)->getParent();
+                this->directParents_.push_back(directParent);
+                directParent->finishInitialization(); // initialize parent
+            }
+            // direct parents and their parents are also parents of this identifier (but only add them once)
+            for (std::list<const Identifier*>::const_iterator it_parent = this->directParents_.begin(); it_parent != this->directParents_.end(); ++it_parent)
+            {
+                for (std::list<const Identifier*>::const_iterator it_parent_parent = const_cast<Identifier*>(*it_parent)->parents_.begin(); it_parent_parent != const_cast<Identifier*>(*it_parent)->parents_.end(); ++it_parent_parent)
+                    this->addIfNotExists(this->parents_, *it_parent_parent);
+                this->addIfNotExists(this->parents_, *it_parent);
+            }
+        }
+        else if (!this->isExactlyA(Class(Identifiable)))
+        {
+            // only Identifiable is allowed to have no parents (even tough it's currently not abstract)
+            orxout(internal_error) << "Identifier " << this->getName() << " / " << this->getTypeInfo().name() << " is marked as abstract but has no direct parents defined" << endl;
             orxout(internal_error) << "  If this class is not abstract, use RegisterClass(ThisClass);" << endl;
             orxout(internal_error) << "  If this class is abstract, use RegisterAbstractClass(ThisClass).inheritsFrom(Class(BaseClass));" << endl;
+        }
+    }
-    /**
-     * @brief Finishes the initialization of this Identifier after creating the class hierarchy by wiring the (direct) parent/child references correctly.
-     */
-    void Identifier::finishInitialization()
+    {
-        if (!IdentifierManager::getInstance().isCreatingHierarchy())
+        {
-            orxout(internal_warning) << "Identifier::finishInitialization() created outside of class hierarchy creation" << endl;
-            return;
+        }
-        if (this->isInitialized())
-            return;
-        // if no direct parents were defined, initialize them with the set of all parents
-        if (this->directParents_.empty())
-            this->directParents_ = this->parents_;
-        // initialize all parents before continuing to initialize this identifier
-        for (std::set<const Identifier*>::const_iterator it = this->directParents_.begin(); it != this->directParents_.end(); ++it)
+        {
-            Identifier* directParent = const_cast<Identifier*>(*it);
-            directParent->finishInitialization(); // initialize parent
-            this->parents_.insert(directParent);  // direct parent is also a parent
-            this->parents_.insert(directParent->parents_.begin(), directParent->parents_.end()); // parents of direct parent are also parents
+        }
-        // parents of parents are no direct parents of this identifier
-        for (std::set<const Identifier*>::const_iterator it_parent = this->parents_.begin(); it_parent != this->parents_.end(); ++it_parent)
-            for (std::set<const Identifier*>::const_iterator it_parent_parent = const_cast<Identifier*>(*it_parent)->parents_.begin(); it_parent_parent != const_cast<Identifier*>(*it_parent)->parents_.end(); ++it_parent_parent)
-                this->directParents_.erase(*it_parent_parent);
         // tell all parents that this identifier is a child
         for (std::set<const Identifier*>::const_iterator it = this->parents_.begin(); it != this->parents_.end(); ++it)
+        for (std::list<const Identifier*>::const_iterator it = this->parents_.begin(); it != this->parents_.end(); ++it)
             const_cast<Identifier*>(*it)->children_.insert(this);
         // tell all direct parents that this identifier is a direct child
         for (std::set<const Identifier*>::const_iterator it = this->directParents_.begin(); it != this->directParents_.end(); ++it)
+        for (std::list<const Identifier*>::const_iterator it = this->directParents_.begin(); it != this->directParents_.end(); ++it)
+        {
             const_cast<Identifier*>(*it)->directChildren_.insert(this);
 …
     /**
+     * Resets all information about the class hierarchy. The identifier is considered uninitialized afterwards.
+     */
+    void Identifier::reset()
+    {
+        this->directParents_.clear();
+        this->parents_.clear();
+        this->directChildren_.clear();
+        this->children_.clear();
+        this->bInitialized_ = false;
+    }
+    /**
+     * Verifies if the recorded trace of parent identifiers matches the expected trace according to the class hierarchy. If it doesn't match, the class
+     * hierarchy is likely wrong, e.g. due to wrong inheritsFrom<>() definitions in abstract classes.
+     */
+    void Identifier::verifyIdentifierTrace() const
+    {
+        std::list<const Identifier*> expectedIdentifierTrace;
+        // if any parent class is virtual, it will be instantiated first, so we need to add them first.
+        for (std::list<const Identifier*>::const_iterator it_parent = this->parents_.begin(); it_parent != this->parents_.end(); ++it_parent)
+        {
+            if ((*it_parent)->isVirtualBase())
+            {
+                for (std::list<const Identifier*>::const_iterator it_parent_parent = const_cast<Identifier*>(*it_parent)->parents_.begin(); it_parent_parent != const_cast<Identifier*>(*it_parent)->parents_.end(); ++it_parent_parent)
+                    this->addIfNotExists(expectedIdentifierTrace, *it_parent_parent);
+                this->addIfNotExists(expectedIdentifierTrace, *it_parent);
+            }
+        }
+        // now all direct parents get created recursively. already added identifiers (e.g. virtual base classes) are not added again.
+        for (std::list<const Identifier*>::const_iterator it_parent = this->directParents_.begin(); it_parent != this->directParents_.end(); ++it_parent)
+        {
+            for (std::list<const Identifier*>::const_iterator it_parent_parent = const_cast<Identifier*>(*it_parent)->parents_.begin(); it_parent_parent != const_cast<Identifier*>(*it_parent)->parents_.end(); ++it_parent_parent)
+                this->addIfNotExists(expectedIdentifierTrace, *it_parent_parent);
+            this->addIfNotExists(expectedIdentifierTrace, *it_parent);
+        }
+        // check if the expected trace matches the actual trace (which was defined by creating a sample instance)
+        if (expectedIdentifierTrace != this->parents_)
+        {
+            orxout(internal_warning) << this->getName() << " has an unexpected initialization trace:" << endl;
+            orxout(internal_warning) << "  Actual trace (after creating a sample instance):" << endl << "    ";
+            for (std::list<const Identifier*>::const_iterator it_parent = this->parents_.begin(); it_parent != this->parents_.end(); ++it_parent)
+                orxout(internal_warning) << " " << (*it_parent)->getName();
+            orxout(internal_warning) << endl;
+            orxout(internal_warning) << "  Expected trace (according to class hierarchy definitions):" << endl << "    ";
+            for (std::list<const Identifier*>::const_iterator it_parent = expectedIdentifierTrace.begin(); it_parent != expectedIdentifierTrace.end(); ++it_parent)
+                orxout(internal_warning) << " " << (*it_parent)->getName();
+            orxout(internal_warning) << endl;
+            orxout(internal_warning) << "  Direct parents (according to class hierarchy definitions):" << endl << "    ";
+            for (std::list<const Identifier*>::const_iterator it_parent = this->directParents_.begin(); it_parent != this->directParents_.end(); ++it_parent)
+                orxout(internal_warning) << " " << (*it_parent)->getName();
+            orxout(internal_warning) << endl;
+        }
+    }
+    /**
+     * Adds @param identifierToAdd to @param list if this identifier is not already contained in the list.
+     */
+    void Identifier::addIfNotExists(std::list<const Identifier*>& list, const Identifier* identifierToAdd) const
+    {
+        if (std::find(list.begin(), list.end(), identifierToAdd) == list.end())
+            list.push_back(identifierToAdd);
+    }
+    /**
         @brief Returns true, if the Identifier is at least of the given type.
         @param identifier The identifier to compare with
 …
     bool Identifier::isA(const Identifier* identifier) const
+    {
         return (identifier == this || (this->parents_.find(identifier) != this->parents_.end()));
+        return (identifier == this || (this->isChildOf(identifier)));
+    }
 …
     bool Identifier::isChildOf(const Identifier* identifier) const
+    {
         return (this->parents_.find(identifier) != this->parents_.end());
+        return (std::find(this->parents_.begin(), this->parents_.end(),  identifier) != this->parents_.end());
+    }
 …
     bool Identifier::isDirectChildOf(const Identifier* identifier) const
+    {
         return (this->directParents_.find(identifier) != this->directParents_.end());
+        return (std::find(this->directParents_.begin(), this->directParents_.end(), identifier) != this->directParents_.end());
+    }

code/trunk/src/libraries/core/class/Identifier.h

-                      r9667
+                      r10624
 #include <typeinfo>
 #include <loki/TypeTraits.h>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_base_of.hpp>
 #include "util/Output.h"
+#include "util/OrxAssert.h"
 #include "core/object/ObjectList.h"
 #include "core/object/Listable.h"
 …
+    {
         public:
+            Identifier();
+            struct InheritsFrom //! helper class to manually define inheritance
+            {
+                virtual ~InheritsFrom() {}
+                virtual Identifier* getParent() const = 0;
+            };
+        public:
+            Identifier(const std::string& name, Factory* factory, bool bLoadable);
             Identifier(const Identifier& identifier); // don't copy
             virtual ~Identifier();
 …
             /// Returns the name of the class the Identifier belongs to.
             inline const std::string& getName() const { return this->name_; }
+            void setName(const std::string& name);
+            /// Returns the name of the class as it is returned by typeid(T).name()
+            virtual const std::string& getTypeidName() = 0;
+            /// Returns the type_info of the class as it is returned by typeid(T)
+            virtual const std::type_info& getTypeInfo() = 0;
             /// Returns the network ID to identify a class through the network.
 …
             ORX_FORCEINLINE unsigned int getClassID() const { return this->classID_; }
-            /// Sets the Factory.
-            void setFactory(Factory* factory);
             /// Returns true if the Identifier has a Factory.
             inline bool hasFactory() const { return (this->factory_ != 0); }
 …
             /// Returns true if the class can be loaded through XML.
             inline bool isLoadable() const { return this->bLoadable_; }
+            /// Set the class to be loadable through XML or not.
+            inline void setLoadable(bool bLoadable) { this->bLoadable_ = bLoadable; }
+            /// Returns true if child classes should inherit virtually from this class.
+            inline bool isVirtualBase() const { return this->bIsVirtualBase_; }
+            /// Defines if child classes should inherit virtually from this class.
+            inline void setVirtualBase(bool bIsVirtualBase) { this->bIsVirtualBase_ = bIsVirtualBase; }
             /// Returns true if the Identifier was completely initialized.
             inline bool isInitialized() const { return this->bInitialized_; }
+            virtual void destroyObjects() = 0;
+            virtual bool canDynamicCastObjectToIdentifierClass(Identifiable* object) const = 0;
+            static bool initConfigValues_s; // TODO: this is a hack - remove it as soon as possible
 …
             ////// Class Hierarchy //////
             /////////////////////////////
+            Identifier& inheritsFrom(Identifier* directParent);
+            void initializeParents(const std::set<const Identifier*>& identifiers);
+            void initializeDirectParentsOfAbstractClass();
+            Identifier& inheritsFrom(InheritsFrom* directParent);
+            void initializeParents(const std::list<const Identifier*>& initializationTrace);
             void finishInitialization();
+            void reset();
             bool isA(const Identifier* identifier) const;
 …
             bool isDirectParentOf(const Identifier* identifier) const;
+            /// Returns the direct parents of the class the Identifier belongs to.
+            inline const std::list<const Identifier*>& getDirectParents() const { return this->directParents_; }
             /// Returns the parents of the class the Identifier belongs to.
+            inline const std::set<const Identifier*>& getParents() const { return this->parents_; }
+            /// Returns the begin-iterator of the parents-list.
+            inline std::set<const Identifier*>::const_iterator getParentsBegin() const { return this->parents_.begin(); }
+            /// Returns the end-iterator of the parents-list.
+            inline std::set<const Identifier*>::const_iterator getParentsEnd() const { return this->parents_.end(); }
+            inline const std::list<const Identifier*>& getParents() const { return this->parents_; }
+            /// Returns the direct children the class the Identifier belongs to.
+            inline const std::set<const Identifier*>& getDirectChildren() const { return this->directChildren_; }
             /// Returns the children of the class the Identifier belongs to.
             inline const std::set<const Identifier*>& getChildren() const { return this->children_; }
-            /// Returns the begin-iterator of the children-list.
-            inline std::set<const Identifier*>::const_iterator getChildrenBegin() const { return this->children_.begin(); }
-            /// Returns the end-iterator of the children-list.
-            inline std::set<const Identifier*>::const_iterator getChildrenEnd() const { return this->children_.end(); }
-            /// Returns the direct parents of the class the Identifier belongs to.
-            inline const std::set<const Identifier*>& getDirectParents() const { return this->directParents_; }
-            /// Returns the begin-iterator of the direct-parents-list.
-            inline std::set<const Identifier*>::const_iterator getDirectParentsBegin() const { return this->directParents_.begin(); }
-            /// Returns the end-iterator of the direct-parents-list.
-            inline std::set<const Identifier*>::const_iterator getDirectParentsEnd() const { return this->directParents_.end(); }
-            /// Returns the direct children the class the Identifier belongs to.
-            inline const std::set<const Identifier*>& getDirectChildren() const { return this->directChildren_; }
-            /// Returns the begin-iterator of the direct-children-list.
-            inline std::set<const Identifier*>::const_iterator getDirectChildrenBegin() const { return this->directChildren_.begin(); }
-            /// Returns the end-iterator of the direct-children-list.
-            inline std::set<const Identifier*>::const_iterator getDirectChildrenEnd() const { return this->directChildren_.end(); }
 …
             XMLPortObjectContainer* getXMLPortObjectContainer(const std::string& sectionname);
         protected:
             virtual void createSuperFunctionCaller() const = 0;
         private:
+            std::set<const Identifier*> parents_;                          //!< The parents of the class the Identifier belongs to
+            void verifyIdentifierTrace() const;
+            void addIfNotExists(std::list<const Identifier*>& list, const Identifier* identifierToAdd) const;
+            std::list<const InheritsFrom*> manualDirectParents_;            //!< Manually defined direct parents
+            std::list<const Identifier*> directParents_;                    //!< The direct parents of the class the Identifier belongs to (sorted by their order of initialization)
+            std::list<const Identifier*> parents_;                          //!< The parents of the class the Identifier belongs to (sorted by their order of initialization)
+            std::set<const Identifier*> directChildren_;                   //!< The direct children of the class the Identifier belongs to
             std::set<const Identifier*> children_;                         //!< The children of the class the Identifier belongs to
-            std::set<const Identifier*> directParents_;                    //!< The direct parents of the class the Identifier belongs to
-            std::set<const Identifier*> directChildren_;                   //!< The direct children of the class the Identifier belongs to
             bool bInitialized_;                                            //!< Is true if the Identifier was completely initialized
             bool bLoadable_;                                               //!< False = it's not permitted to load the object through XML
+            bool bIsVirtualBase_;                                          //!< If true, it is recommended to inherit virtually from this class. This changes the order of initialization of child classes, thus this information is necessary to check the class hierarchy.
             std::string name_;                                             //!< The name of the class the Identifier belongs to
             Factory* factory_;                                             //!< The Factory, able to create new objects of the given class (if available)
             uint32_t networkID_;                                           //!< The network ID to identify a class through the network
             const unsigned int classID_;                                   //!< Uniquely identifies a class (might not be the same as the networkID_)
+            unsigned int classID_;                                         //!< Uniquely identifies a class (might not be the same as the networkID_)
             bool bHasConfigValues_;                                        //!< True if this class has at least one assigned config value
 …
     class ClassIdentifier : public Identifier
+    {
+        BOOST_STATIC_ASSERT((boost::is_base_of<Identifiable, T>::value));
         #ifndef DOXYGEN_SHOULD_SKIP_THIS
           #define SUPER_INTRUSIVE_DECLARATION_INCLUDE
 …
         public:
+            static ClassIdentifier<T>* getIdentifier();
+            static ClassIdentifier<T>* getIdentifier(const std::string& name);
+            bool initializeObject(T* object);
+            void setConfigValues(T* object, Configurable*) const;
+            void setConfigValues(T* object, Identifiable*) const;
+            void addObjectToList(T* object, Listable*);
+            void addObjectToList(T* object, Identifiable*);
+            virtual void updateConfigValues(bool updateChildren = true) const;
+            virtual const std::string& getTypeidName()
+                { return this->typeidName_; }
+        private:
+            static void initializeIdentifier();
+            ClassIdentifier(const ClassIdentifier<T>& identifier) {}    // don't copy
+            ClassIdentifier()
+            ClassIdentifier(const std::string& name, Factory* factory, bool bLoadable) : Identifier(name, factory, bLoadable)
+            {
+                this->typeidName_ = typeid(T).name();
+                OrxVerify(ClassIdentifier<T>::classIdentifier_s == NULL, "Assertion failed in ClassIdentifier of type " << typeid(T).name());
+                ClassIdentifier<T>::classIdentifier_s = this;
                 SuperFunctionInitialization<0, T>::initialize(this);
+            }
 …
+            }
+            bool initializeObject(T* object);
+            virtual void updateConfigValues(bool updateChildren = true) const;
+            virtual const std::type_info& getTypeInfo()
+                { return typeid(T); }
+            virtual bool canDynamicCastObjectToIdentifierClass(Identifiable* object) const
+                { return dynamic_cast<T*>(object) != 0; }
+            virtual void destroyObjects();
+            static ClassIdentifier<T>* getIdentifier();
+        private:
+            ClassIdentifier(const ClassIdentifier<T>& identifier) {}    // don't copy
+            void setConfigValues(T* object, Configurable*) const;
+            void setConfigValues(T* object, Identifiable*) const;
+            void addObjectToList(T* object, Listable*);
+            void addObjectToList(T* object, Identifiable*);
+            void destroyObjects(Listable*);
+            void destroyObjects(void*);
+            void destroyObject(Destroyable* object);
+            void destroyObject(void* object);
             void updateConfigValues(bool updateChildren, Listable*) const;
             void updateConfigValues(bool updateChildren, Identifiable*) const;
-            std::string typeidName_;
             static WeakPtr<ClassIdentifier<T> > classIdentifier_s;
     };
 …
     */
     template <class T>
     inline ClassIdentifier<T>* ClassIdentifier<T>::getIdentifier()
+    {
         // check if the Identifier already exists
         if (!ClassIdentifier<T>::classIdentifier_s)
+            ClassIdentifier<T>::initializeIdentifier();
+    /*static*/ inline ClassIdentifier<T>* ClassIdentifier<T>::getIdentifier()
+    {
+        if (ClassIdentifier<T>::classIdentifier_s == NULL)
+            ClassIdentifier<T>::classIdentifier_s = (ClassIdentifier<T>*) IdentifierManager::getInstance().getIdentifierByTypeInfo(typeid(T));
+        OrxVerify(ClassIdentifier<T>::classIdentifier_s != NULL, "Did you forget to register the class of type " << typeid(T).name() << "?");
         return ClassIdentifier<T>::classIdentifier_s;
+    }
-    /**
-        @brief Does the same as getIdentifier() but sets the name if this wasn't done yet.
-        @param name The name of this Identifier
-        @return The Identifier
-    */
-    template <class T>
-    inline ClassIdentifier<T>* ClassIdentifier<T>::getIdentifier(const std::string& name)
+    {
-        ClassIdentifier<T>* identifier = ClassIdentifier<T>::getIdentifier();
-        identifier->setName(name);
-        return identifier;
+    }
-    /**
-        @brief Assigns the static field for the identifier singleton.
-    */
-    template <class T>
-    /*static */ void ClassIdentifier<T>::initializeIdentifier()
+    {
-        // create a new identifier anyway. Will be deleted if not used.
-        ClassIdentifier<T>* proposal = new ClassIdentifier<T>();
-        // Get the entry from the map
-        ClassIdentifier<T>::classIdentifier_s = (ClassIdentifier<T>*)IdentifierManager::getInstance().getGloballyUniqueIdentifier(proposal);
-        if (ClassIdentifier<T>::classIdentifier_s == proposal)
-            orxout(verbose, context::identifier) << "Requested Identifier for " << proposal->getTypeidName() << " was not yet existing and got created." << endl;
-        else
+        {
-            orxout(verbose, context::identifier) << "Requested Identifier for " << proposal->getTypeidName() << " was already existing and got assigned." << endl;
-            delete proposal; // delete proposal (it is not used anymore)
+        }
+    }
 …
             IdentifierManager::getInstance().createdObject(object);
+            this->setConfigValues(object, object);
+            if (Identifier::initConfigValues_s)
+                this->setConfigValues(object, object);
             return true;
+        }
 …
     /**
+     * @brief Destroy all objects of this class (must be Listable).
+     * Destroyables are destroyed with destroy(), all other classes with delete.
+     */
+    template <class T>
+    void ClassIdentifier<T>::destroyObjects()
+    {
+        this->destroyObjects((T*)0);
+    }
+    /**
+     * @brief Only searches and destroys objects if is a @ref Listable
+     */
+    template <class T>
+    void ClassIdentifier<T>::destroyObjects(Listable*)
+    {
+        ObjectListBase* objectList = Context::getRootContext()->getObjectList(this);
+        ObjectListElement<T>* begin = static_cast<ObjectListElement<T>*>(objectList->begin());
+        ObjectListElement<T>* end = static_cast<ObjectListElement<T>*>(objectList->end());
+        for (typename ObjectList<T>::iterator it = begin; it != end; )
+            this->destroyObject(*(it++));
+    }
+    template <class T>
+    void ClassIdentifier<T>::destroyObjects(void*)
+    {
+        // no action
+    }
+    /**
+     * @brief Call 'object->destroy()' for Destroyables and 'delete object' for all other types.
+     */
+    template <class T>
+    void ClassIdentifier<T>::destroyObject(Destroyable* object)
+    {
+        object->destroy();
+    }
+    template <class T>
+    void ClassIdentifier<T>::destroyObject(void* object)
+    {
+        delete static_cast<Identifiable*>(object);
+    }
+    /**
         @brief Updates the config-values of all existing objects of this class by calling their setConfigValues() function.
     */
 …
         if (updateChildren)
             for (std::set<const Identifier*>::const_iterator it = this->getChildrenBegin(); it != this->getChildrenEnd(); ++it)
+            for (std::set<const Identifier*>::const_iterator it = this->getChildren().begin(); it != this->getChildren().end(); ++it)
                 (*it)->updateConfigValues(false);
+    }

code/trunk/src/libraries/core/class/IdentifierManager.cc

-                      r9667
+                      r10624
 #include "util/StringUtils.h"
 #include "core/CoreIncludes.h"
+#include "core/Core.h"
 #include "core/config/ConfigValueContainer.h"
 #include "core/XMLPort.h"
 …
 namespace orxonox
+{
+    /* static */ IdentifierManager& IdentifierManager::getInstance()
+    {
+        static IdentifierManager instance;
+        return instance;
+    }
+    IdentifierManager* IdentifierManager::singletonPtr_s = 0;
     IdentifierManager::IdentifierManager()
+    {
         this->hierarchyCreatingCounter_s = 0;
+        this->classIDCounter_s = 0;
+    }
+    /**
+        @brief Returns an identifier by name and adds it if not available
+        @param proposal A pointer to a newly created identifier for the case of non existence in the map
+        @return The identifier (unique instance)
+    */
+    Identifier* IdentifierManager::getGloballyUniqueIdentifier(Identifier* proposal)
+    {
+        const std::string& typeidName = proposal->getTypeidName();
+        std::map<std::string, Identifier*>::const_iterator it = this->identifierByTypeidName_.find(typeidName);
+        if (it != this->identifierByTypeidName_.end())
+        {
+            // There is already an entry: return it
+            return it->second;
+        }
+        else
+        {
+            // There is no entry: put the proposal into the map and return it
+            this->identifierByTypeidName_[typeidName] = proposal;
+            return proposal;
+        }
+        this->recordTraceForIdentifier_ = NULL;
+    }
 …
      * Registers the identifier in all maps of the IdentifierManager.
      */
+    void IdentifierManager::addIdentifierToLookupMaps(Identifier* identifier)
+    {
+        const std::string& typeidName = identifier->getTypeidName();
+        if (this->identifierByTypeidName_.find(typeidName) != this->identifierByTypeidName_.end())
+        {
+            this->identifierByString_[identifier->getName()] = identifier;
+            this->identifierByLowercaseString_[getLowercase(identifier->getName())] = identifier;
+            this->identifierByNetworkId_[identifier->getNetworkID()] = identifier;
+        }
+        else
+            orxout(internal_warning) << "Trying to add an identifier to lookup maps which is not known to IdentifierManager" << endl;
+    void IdentifierManager::addIdentifier(Identifier* identifier)
+    {
+        orxout(verbose, context::identifier) << "Adding identifier for " << identifier->getName() << " / " << identifier->getTypeInfo().name() << endl;
+        this->identifiers_.insert(identifier);
+        this->identifierByString_[identifier->getName()] = identifier;
+        this->identifierByLowercaseString_[getLowercase(identifier->getName())] = identifier;
+        this->identifierByNetworkId_[identifier->getNetworkID()] = identifier;
+    }
+    /**
+     * Unregisters the identifier from all maps of the IdentifierManager.
+     */
+    void IdentifierManager::removeIdentifier(Identifier* identifier)
+    {
+        this->identifiers_.erase(identifier);
+        this->identifierByString_.erase(identifier->getName());
+        this->identifierByLowercaseString_.erase(getLowercase(identifier->getName()));
+        this->identifierByNetworkId_.erase(identifier->getNetworkID());
+    }
 …
+        {
             Context temporaryContext(NULL);
             for (std::map<std::string, Identifier*>::const_iterator it = this->identifierByTypeidName_.begin(); it != this->identifierByTypeidName_.end(); ++it)
+            for (std::set<Identifier*>::const_iterator it = this->identifiers_.begin(); it != this->identifiers_.end(); ++it)
+            {
+                orxout(verbose, context::identifier) << "Initialize ClassIdentifier<" << it->second->getName() << ">-Singleton." << endl;
+                Identifier* identifier = (*it);
+                if (identifier->isInitialized())
+                    continue;
+                orxout(verbose, context::identifier) << "Initialize ClassIdentifier<" << identifier->getName() << ">-Singleton." << endl;
                 // To initialize the identifier, we create a new object and delete it afterwards.
                 if (it->second->hasFactory())
+                if (identifier->hasFactory())
+                {
+                    this->identifiersOfNewObject_.clear();
+                    Identifiable* temp = it->second->fabricate(&temporaryContext);
+                    if (temp->getIdentifier() != it->second)
+                        orxout(internal_error) << "Newly created object of type " << it->second->getName() << " has unexpected identifier. Did you forget to use RegisterObject(classname)?" << endl;
+                    this->identifierTraceOfNewObject_.clear();
+                    this->recordTraceForIdentifier_ = identifier;
+                    Identifiable* temp = identifier->fabricate(&temporaryContext);
+                    this->recordTraceForIdentifier_ = NULL;
+                    if (temp->getIdentifier() != identifier)
+                        orxout(internal_error) << "Newly created object of type " << identifier->getName() << " has unexpected identifier. Did you forget to use RegisterObject(classname)?" << endl;
+                    identifier->initializeParents(this->identifierTraceOfNewObject_[temp]);
                     delete temp;
-                    it->second->initializeParents(this->identifiersOfNewObject_);
+                }
+                else
+                    it->second->initializeDirectParentsOfAbstractClass();
+                initializedIdentifiers.insert(it->second);
+                initializedIdentifiers.insert(identifier);
+            }
 …
         // finish the initialization of all identifiers
+        for (std::map<std::string, Identifier*>::const_iterator it = this->identifierByTypeidName_.begin(); it != this->identifierByTypeidName_.end(); ++it)
+        {
+            if (initializedIdentifiers.find(it->second) != initializedIdentifiers.end())
+                it->second->finishInitialization();
+            else
+                orxout(internal_error) << "Identifier was registered late and is not initialized: " << it->second->getName() << " / " << it->second->getTypeidName() << endl;
+        }
+        for (std::set<Identifier*>::const_iterator it = initializedIdentifiers.begin(); it != initializedIdentifiers.end(); ++it)
+            (*it)->finishInitialization();
+        // only check class hierarchy in dev mode because it's an expensive operation and it requires a developer to fix detected problems anyway.
+        if (!Core::exists() || Core::getInstance().getConfig()->inDevMode())
+            this->verifyClassHierarchy(initializedIdentifiers);
         this->stopCreatingHierarchy();
 …
     /**
+        @brief Destroys all Identifiers. Called when exiting the program.
+    */
+    void IdentifierManager::destroyAllIdentifiers()
+    {
+        for (std::map<std::string, Identifier*>::iterator it = this->identifierByTypeidName_.begin(); it != this->identifierByTypeidName_.end(); ++it)
+            delete (it->second);
+        this->identifierByTypeidName_.clear();
+        this->identifierByString_.clear();
+        this->identifierByLowercaseString_.clear();
+        this->identifierByNetworkId_.clear();
+     * Verifies if the class hierarchy is consistent with the RTTI.
+     */
+    void IdentifierManager::verifyClassHierarchy(const std::set<Identifier*>& initializedIdentifiers)
+    {
+        // check if there are any uninitialized identifiers remaining
+        for (std::set<Identifier*>::const_iterator it = this->identifiers_.begin(); it != this->identifiers_.end(); ++it)
+            if (!(*it)->isInitialized())
+                orxout(internal_error) << "Identifier was registered late and is not initialized: " << (*it)->getName() << " / " << (*it)->getTypeInfo().name() << endl;
+        // for all initialized identifiers, check if a sample instance behaves as expected according to the class hierarchy
+        Context temporaryContext(NULL);
+        for (std::set<Identifier*>::const_iterator it1 = initializedIdentifiers.begin(); it1 != initializedIdentifiers.end(); ++it1)
+        {
+            if (!(*it1)->hasFactory())
+                continue;
+            Identifiable* temp = (*it1)->fabricate(&temporaryContext);
+            for (std::set<Identifier*>::const_iterator it2 = this->identifiers_.begin(); it2 != this->identifiers_.end(); ++it2)
+            {
+                bool isA_AccordingToRtti = (*it2)->canDynamicCastObjectToIdentifierClass(temp);
+                bool isA_AccordingToClassHierarchy = temp->isA((*it2));
+                if (isA_AccordingToRtti != isA_AccordingToClassHierarchy)
+                {
+                    orxout(internal_error) << "Class hierarchy does not match RTTI: Class hierarchy claims that " << (*it1)->getName() <<
+                        (isA_AccordingToClassHierarchy ? " is a " : " is not a ") << (*it2)->getName() << " but RTTI says the opposite." << endl;
+                }
+            }
+            delete temp;
+        }
+        orxout(internal_info) << "Class hierarchy matches RTTI" << endl;
+        size_t numberOfObjects = temporaryContext.getObjectList<Listable>()->size();
+        if (numberOfObjects > 0)
+            orxout(internal_warning) << "There are still " << numberOfObjects << " listables left after creating the class hierarchy" << endl;
+    }
+    /**
+     * @brief Resets all Identifiers.
+     */
+    void IdentifierManager::destroyClassHierarchy()
+    {
+        orxout(internal_status) << "Destroy class-hierarchy" << endl;
+        for (std::set<Identifier*>::const_iterator it = this->identifiers_.begin(); it != this->identifiers_.end(); ++it)
+            (*it)->reset();
+    }
 …
+    {
         if (this->isCreatingHierarchy())
+            this->identifiersOfNewObject_.insert(identifiable->getIdentifier());
+        {
+            if (this->recordTraceForIdentifier_)
+            {
+                std::list<const Identifier*>& traceForObject = this->identifierTraceOfNewObject_[identifiable];
+                if (std::find(traceForObject.begin(), traceForObject.end(), identifiable->getIdentifier()) != traceForObject.end())
+                {
+                    orxout(internal_warning) << this->recordTraceForIdentifier_->getName() << " inherits two times from " <<
+                        identifiable->getIdentifier()->getName() << ". Did you forget to use virtual inheritance?" << endl;
+                }
+                traceForObject.push_back(identifiable->getIdentifier());
+            }
+        }
         else
             orxout(internal_warning) << "createdObject() called outside of class hierarchy creation" << endl;
 …
     /**
+        @brief Returns the Identifier with a given typeid-name.
+        @param name The typeid-name of the wanted Identifier
+        @return The Identifier
+    */
+    Identifier* IdentifierManager::getIdentifierByTypeInfo(const std::type_info& typeInfo)
+    {
+        // TODO: use std::type_index and a map to find identifiers by type_info (only with c++11)
+        for (std::set<Identifier*>::iterator it = this->identifiers_.begin(); it != this->identifiers_.end(); ++it)
+            if ((*it)->getTypeInfo() == typeInfo)
+                return (*it);
+        return 0;
+    }
+    /**
         @brief Cleans the NetworkID map (needed on clients for correct initialization)
     */

code/trunk/src/libraries/core/class/IdentifierManager.h

-                      r9667
+                      r10624
 #include <map>
 #include <set>
+#include <list>
 #include <string>
+#include "util/Singleton.h"
 namespace orxonox
+{
     class _CoreExport IdentifierManager
+    class _CoreExport IdentifierManager : public Singleton<IdentifierManager>
+    {
+        friend class Singleton<IdentifierManager>;
         public:
+            static IdentifierManager& getInstance();
+            IdentifierManager();
+            ~IdentifierManager() {}
+            Identifier* getGloballyUniqueIdentifier(Identifier* proposal);
+            void addIdentifierToLookupMaps(Identifier* identifier);
+            unsigned int getUniqueClassId()
+                { return this->classIDCounter_s++; }
+            void addIdentifier(Identifier* identifier);
+            void removeIdentifier(Identifier* identifier);
 …
             /////////////////////////////
             void createClassHierarchy();
+            void destroyAllIdentifiers();
+            void verifyClassHierarchy(const std::set<Identifier*>& initializedIdentifiers);
+            void destroyClassHierarchy();
             void createdObject(Identifiable* identifiable);
 …
             Identifier* getIdentifierByLowercaseString(const std::string& name);
             Identifier* getIdentifierByID(uint32_t id);
+            Identifier* getIdentifierByTypeInfo(const std::type_info& typeInfo);
             void clearNetworkIDs();
 …
         private:
+            IdentifierManager();
+            IdentifierManager(const IdentifierManager&);
+            ~IdentifierManager() {}
+            IdentifierManager(const IdentifierManager&); // not implemented
             /// Increases the hierarchyCreatingCounter_s variable, causing all new objects to store their parents.
 …
                 { hierarchyCreatingCounter_s--; }
+            std::map<std::string, Identifier*> identifierByTypeidName_;      //!< Map with the names as received by typeid(). This is only used internally.
+            std::set<Identifier*> identifiers_;                              //!< All identifiers. This is only used internally.
             std::map<std::string, Identifier*> identifierByString_;          //!< Map that stores all Identifiers with their names.
             std::map<std::string, Identifier*> identifierByLowercaseString_; //!< Map that stores all Identifiers with their names in lowercase.
 …
             int hierarchyCreatingCounter_s;                         //!< Bigger than zero if at least one Identifier stores its parents (its an int instead of a bool to avoid conflicts with multithreading)
+            std::set<const Identifier*> identifiersOfNewObject_;    //!< Used while creating the object hierarchy to keep track of the identifiers of a newly created object
+            unsigned int classIDCounter_s;                          //!< counter for the unique classIDs
+            /// Used while creating the object hierarchy to keep track of the identifiers of a newly created object (and all other objects that get created as
+            /// a consequence of this, e.g. nested member objects).
+            std::map<Identifiable*, std::list<const Identifier*> > identifierTraceOfNewObject_;
+            Identifier* recordTraceForIdentifier_; //!< The identifier for which we want to record the trace of identifiers during object creation. If null, no trace is recorded.
+            static IdentifierManager* singletonPtr_s;
     };
+}

code/trunk/src/libraries/core/class/OrxonoxInterface.cc

r9667	r10624
32	32	namespace orxonox
33	33	{
34		RegisterClassNoArgs(OrxonoxInterface);
	34	RegisterClassNoArgs(OrxonoxInterface).virtualBase();
35	35
36	36	OrxonoxInterface::OrxonoxInterface()

code/trunk/src/libraries/core/class/Super.h

-                      r9667
+                      r10624
         SUPER_NOARGS(classname, functionname)
-    #define SUPER_changedGametype(classname, functionname, ...) \
-        SUPER_NOARGS(classname, functionname)
     #define SUPER_changedUsed(classname, functionname, ...) \
         SUPER_NOARGS(classname, functionname)
 …
         SUPER_FUNCTION_GLOBAL_DECLARATION_PART2;
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART1(9, changedGametype, false)
+            ()
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART2;
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART1(10, changedUsed, false)
+            ()
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART2;
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART1(11, changedCarrier, false)
+            ()
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART2;
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART1(12, changedPickedUp, false)
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART1(9, changedUsed, false)
+            ()
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART2;
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART1(10, changedCarrier, false)
+            ()
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART2;
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART1(11, changedPickedUp, false)
             ()
         SUPER_FUNCTION_GLOBAL_DECLARATION_PART2;
 …
     SUPER_INTRUSIVE_DECLARATION(changedOverlayGroup);
     SUPER_INTRUSIVE_DECLARATION(changedName);
-    SUPER_INTRUSIVE_DECLARATION(changedGametype);
     SUPER_INTRUSIVE_DECLARATION(changedUsed);
     SUPER_INTRUSIVE_DECLARATION(changedCarrier);

code/trunk/src/libraries/core/command/ArgumentCompletionFunctions.cc

-                      r9667
+                      r10624
 #include "CommandExecutor.h"
 #include "ConsoleCommand.h"
+#include "ConsoleCommandManager.h"
 #include "TclThreadManager.h"
 …
                 // get all the groups that are visible (except the shortcut group "")
                 const std::map<std::string, std::map<std::string, ConsoleCommand*> >& commands = ConsoleCommand::getCommands();
+                const std::map<std::string, std::map<std::string, ConsoleCommand*> >& commands = ConsoleCommandManager::getInstance().getCommands();
                 for (std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = commands.begin(); it_group != commands.end(); ++it_group)
                     if (groupIsVisible(it_group->second, bOnlyShowHidden) && it_group->first != "" && (fragmentLC == "" || getLowercase(it_group->first).find(fragmentLC) == 0))
 …
                 // find the iterator of the given group
                 std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommand::getCommands().begin();
                 for ( ; it_group != ConsoleCommand::getCommands().end(); ++it_group)
+                std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommandManager::getInstance().getCommands().begin();
+                for ( ; it_group != ConsoleCommandManager::getInstance().getCommands().end(); ++it_group)
                     if (getLowercase(it_group->first) == groupLC)
                         break;
                 // add all commands in the group to the list
                 if (it_group != ConsoleCommand::getCommands().end())
+                if (it_group != ConsoleCommandManager::getInstance().getCommands().end())
+                {
                     for (std::map<std::string, ConsoleCommand*>::const_iterator it_command = it_group->second.begin(); it_command != it_group->second.end(); ++it_command)
 …
                 return detail::_groupsandcommands(fragment, true);
             if (ConsoleCommand::getCommandLC(getLowercase(tokens[0])))
+            if (ConsoleCommandManager::getInstance().getCommandLC(getLowercase(tokens[0])))
                 return ARGUMENT_COMPLETION_FUNCTION_CALL(command)(fragment);
             if (tokens.size() == 1)
+            {
                 std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommand::getCommands().find(tokens[0]);
                 if (it_group != ConsoleCommand::getCommands().end())
+                std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommandManager::getInstance().getCommands().find(tokens[0]);
+                if (it_group != ConsoleCommandManager::getInstance().getCommands().end())
                     return detail::_subcommands(fragment, tokens[0], true);
                 else
 …
+            }
             if (ConsoleCommand::getCommandLC(getLowercase(tokens[0]), getLowercase(tokens[1])))
+            if (ConsoleCommandManager::getInstance().getCommandLC(getLowercase(tokens[0]), getLowercase(tokens[1])))
                 return ARGUMENT_COMPLETION_FUNCTION_CALL(command)(fragment);

code/trunk/src/libraries/core/command/CMakeLists.txt

r7284	r10624
4	4	ConsoleCommand.cc
5	5	ConsoleCommandCompilation.cc
	6	ConsoleCommandIncludes.cc
	7	ConsoleCommandManager.cc
6	8	Executor.cc
7	9	IOConsole.cc

code/trunk/src/libraries/core/command/CommandEvaluation.cc

-                      r9550
+                      r10624
 #include "CommandExecutor.h"
 #include "ConsoleCommand.h"
+#include "ConsoleCommandManager.h"
 namespace orxonox
 …
                 // the user typed 1-2 arguments, check what he tried to type and print a suitable error
                 std::string groupLC = getLowercase(this->getToken(0));
                 for (std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommand::getCommandsLC().begin(); it_group != ConsoleCommand::getCommandsLC().end(); ++it_group)
+                for (std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommandManager::getInstance().getCommandsLC().begin(); it_group != ConsoleCommandManager::getInstance().getCommandsLC().end(); ++it_group)
                     if (it_group->first == groupLC)
                         return std::string("Error: There is no command in group \"") + this->getToken(0) + "\" starting with \"" + this->getToken(1) + "\".";
 …
         // iterate through all groups and their commands and calculate the distance to the current command. keep the best.
         for (std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommand::getCommandsLC().begin(); it_group != ConsoleCommand::getCommandsLC().end(); ++it_group)
+        for (std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommandManager::getInstance().getCommandsLC().begin(); it_group != ConsoleCommandManager::getInstance().getCommandsLC().end(); ++it_group)
+        {
             if (it_group->first != "")
 …
         // now also iterate through all shortcuts and keep the best if it's better than the one found above.
         std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommand::getCommandsLC().find("");
         if (it_group !=  ConsoleCommand::getCommandsLC().end())
+        std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommandManager::getInstance().getCommandsLC().find("");
+        if (it_group !=  ConsoleCommandManager::getInstance().getCommandsLC().end())
+        {
             for (std::map<std::string, ConsoleCommand*>::const_iterator it_name = it_group->second.begin(); it_name != it_group->second.end(); ++it_name)

code/trunk/src/libraries/core/command/CommandExecutor.cc

-                      r9550
+                      r10624
 #include "CommandExecutor.h"
 #include "ConsoleCommand.h"
+#include "ConsoleCommandIncludes.h"
 #include "TclBind.h"
 #include "Shell.h"
 …
         // assign the fallback-command to get hints about the possible commands and groups
         evaluation.hintCommand_ = ConsoleCommand::getCommand(__CC_CommandExecutor_name, __CC_autocomplete_name);
+        evaluation.hintCommand_ = ConsoleCommandManager::getInstance().getCommand(__CC_CommandExecutor_name, __CC_autocomplete_name);
         // check if there's at least one argument
 …
+        {
             // try to get a command from the first token
             evaluation.execCommand_ = ConsoleCommand::getCommandLC(evaluation.getToken(0));
+            evaluation.execCommand_ = ConsoleCommandManager::getInstance().getCommandLC(evaluation.getToken(0));
             if (evaluation.execCommand_)
                 evaluation.execArgumentsOffset_ = 1;
 …
+            {
                 // try to get a command from the first two tokens
                 evaluation.execCommand_ = ConsoleCommand::getCommandLC(evaluation.getToken(0), evaluation.getToken(1));
+                evaluation.execCommand_ = ConsoleCommandManager::getInstance().getCommandLC(evaluation.getToken(0), evaluation.getToken(1));
                 if (evaluation.execCommand_)
                     evaluation.execArgumentsOffset_ = 2;
 …
             // check if the alias already exists - print an error and return if it does
             if ((tokens.size() == 1 && ConsoleCommand::getCommand(tokens[0])) || (tokens.size() == 2 && ConsoleCommand::getCommand(tokens[0], tokens[1])))
+            if ((tokens.size() == 1 && ConsoleCommandManager::getInstance().getCommand(tokens[0])) || (tokens.size() == 2 && ConsoleCommandManager::getInstance().getCommand(tokens[0], tokens[1])))
+            {
                 orxout(user_error) << "A command with name \"" << alias << "\" already exists." << endl;
 …
             // create a new console command with the given alias as its name
             if (tokens.size() == 1)
                 createConsoleCommand(tokens[0], executor);
+                ConsoleCommandManager::getInstance().registerCommand(new ConsoleCommand(tokens[0], executor));
             else if (tokens.size() == 2)
                 createConsoleCommand(tokens[0], tokens[1], executor);
+                ConsoleCommandManager::getInstance().registerCommand(new ConsoleCommand(tokens[0], tokens[1], executor));
             else
                 orxout(user_error) << "\"" << alias << "\" is not a valid alias name (must have one or two words)." << endl;

code/trunk/src/libraries/core/command/ConsoleCommand.cc

-                      r9348
+                      r10624
 #include "util/Convert.h"
-#include "util/StringUtils.h"
 #include "core/Language.h"
 #include "core/GameMode.h"
 #include "core/input/KeyBinder.h"
 #include "core/input/KeyBinderManager.h"
+#include "ConsoleCommandManager.h"
 namespace orxonox
+{
     /**
+        @brief Constructor: Initializes all values and registers the command.
+        @brief Constructor: Initializes all values and registers the command (without a group).
+        @param name The name of the command
+        @param executor The executor of the command
+        @param bInitialized If true, the executor is used for both, the definition of the function-header AND to executute the command. If false, the command is inactive and needs to be assigned a function before it can be used.
+    */
+    ConsoleCommand::ConsoleCommand(const std::string& name, const ExecutorPtr& executor, bool bInitialized)
+    {
+        this->init("", name, executor, bInitialized);
+    }
+    /**
+        @brief Constructor: Initializes all values and registers the command (with a group).
         @param group The group of the command
         @param name The name of the command
 …
     ConsoleCommand::ConsoleCommand(const std::string& group, const std::string& name, const ExecutorPtr& executor, bool bInitialized)
+    {
+        this->init(group, name, executor, bInitialized);
+    }
+    void ConsoleCommand::init(const std::string& group, const std::string& name, const ExecutorPtr& executor, bool bInitialized)
+    {
         this->bActive_ = true;
         this->bHidden_ = false;
 …
             this->executor_ = executor;
         ConsoleCommand::registerCommand(group, name, this);
+        this->names_.push_back(CommandName(group, name));
+    }
 …
     ConsoleCommand::~ConsoleCommand()
+    {
-        ConsoleCommand::unregisterCommand(this);
+    }
 …
     ConsoleCommand& ConsoleCommand::addShortcut()
+    {
         ConsoleCommand::registerCommand("", this->baseName_, this);
+        this->names_.push_back(CommandName("", this->baseName_));
         return *this;
+    }
 …
     ConsoleCommand& ConsoleCommand::addShortcut(const std::string&  name)
+    {
         ConsoleCommand::registerCommand("", name, this);
+        this->names_.push_back(CommandName("", name));
         return *this;
+    }
 …
     ConsoleCommand& ConsoleCommand::addGroup(const std::string& group)
+    {
         ConsoleCommand::registerCommand(group, this->baseName_, this);
+        this->names_.push_back(CommandName(group, this->baseName_));
         return *this;
+    }
 …
     ConsoleCommand& ConsoleCommand::addGroup(const std::string& group, const std::string&  name)
+    {
         ConsoleCommand::registerCommand(group, name, this);
+        this->names_.push_back(CommandName(group, name));
         return *this;
+    }
 …
         return *this;
+    }
-    /**
-        @brief Returns the command with given group an name.
-        @param group The group of the requested command
-        @param name The group of the requested command
-        @param bPrintError If true, an error is printed if the command doesn't exist
-    */
-    /* static */ ConsoleCommand* ConsoleCommand::getCommand(const std::string& group, const std::string& name, bool bPrintError)
+    {
-        // find the group
-        std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommand::getCommandMap().find(group);
-        if (it_group != ConsoleCommand::getCommandMap().end())
+        {
-            // find the name
-            std::map<std::string, ConsoleCommand*>::const_iterator it_name = it_group->second.find(name);
-            if (it_name != it_group->second.end())
+            {
-                // return the pointer
-                return it_name->second;
+            }
+        }
-        if (bPrintError)
+        {
-            if (group == "")
-                orxout(internal_error, context::commands) << "Couldn't find console command with shortcut \"" << name << "\"" << endl;
-            else
-                orxout(internal_error, context::commands) << "Couldn't find console command with group \"" << group << "\" and name \"" << name << "\"" << endl;
+        }
-        return 0;
+    }
-    /**
-        @brief Returns the command with given group an name in lowercase.
-        @param group The group of the requested command in lowercase
-        @param name The group of the requested command in lowercase
-        @param bPrintError If true, an error is printed if the command doesn't exist
-    */
-    /* static */ ConsoleCommand* ConsoleCommand::getCommandLC(const std::string& group, const std::string& name, bool bPrintError)
+    {
-        std::string groupLC = getLowercase(group);
-        std::string nameLC = getLowercase(name);
-        // find the group
-        std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommand::getCommandMapLC().find(groupLC);
-        if (it_group != ConsoleCommand::getCommandMapLC().end())
+        {
-            // find the name
-            std::map<std::string, ConsoleCommand*>::const_iterator it_name = it_group->second.find(nameLC);
-            if (it_name != it_group->second.end())
+            {
-                // return the pointer
-                return it_name->second;
+            }
+        }
-        if (bPrintError)
+        {
-            if (group == "")
-                orxout(internal_error, context::commands) << "Couldn't find console command with shortcut \"" << name << "\"" << endl;
-            else
-                orxout(internal_error, context::commands) << "Couldn't find console command with group \"" << group << "\" and name \"" << name << "\"" << endl;
+        }
-        return 0;
+    }
-    /**
-        @brief Returns the static map that stores all console commands.
-    */
-    /* static */ std::map<std::string, std::map<std::string, ConsoleCommand*> >& ConsoleCommand::getCommandMap()
+    {
-        static std::map<std::string, std::map<std::string, ConsoleCommand*> > commandMap;
-        return commandMap;
+    }
-    /**
-        @brief Returns the static map that stores all console commands in lowercase.
-    */
-    /* static */ std::map<std::string, std::map<std::string, ConsoleCommand*> >& ConsoleCommand::getCommandMapLC()
+    {
-        static std::map<std::string, std::map<std::string, ConsoleCommand*> > commandMapLC;
-        return commandMapLC;
+    }
-    /**
-        @brief Registers a new command with given group an name by adding it to the command map.
-    */
-    /* static */ void ConsoleCommand::registerCommand(const std::string& group, const std::string& name, ConsoleCommand* command)
+    {
-        if (name == "")
-            return;
-        // check if a command with this name already exists
-        if (ConsoleCommand::getCommand(group, name) != 0)
+        {
-            if (group == "")
-                orxout(internal_warning, context::commands) << "A console command with shortcut \"" << name << "\" already exists." << endl;
-            else
-                orxout(internal_warning, context::commands) << "A console command with name \"" << name << "\" already exists in group \"" << group << "\"." << endl;
+        }
-        else
+        {
-            // add the command to the map
-            ConsoleCommand::getCommandMap()[group][name] = command;
-            ConsoleCommand::getCommandMapLC()[getLowercase(group)][getLowercase(name)] = command;
+        }
+    }
-    /**
-        @brief Removes the command from the command map.
-    */
-    /* static */ void ConsoleCommand::unregisterCommand(ConsoleCommand* command)
+    {
-        // iterate through all groups
-        for (std::map<std::string, std::map<std::string, ConsoleCommand*> >::iterator it_group = ConsoleCommand::getCommandMap().begin(); it_group != ConsoleCommand::getCommandMap().end(); )
+        {
-            // iterate through all commands of each group
-            for (std::map<std::string, ConsoleCommand*>::iterator it_name = it_group->second.begin(); it_name != it_group->second.end(); )
+            {
-                // erase the command
-                if (it_name->second == command)
-                    it_group->second.erase(it_name++);
-                else
-                    ++it_name;
+            }
-            // erase the group if it is empty now
-            if (it_group->second.empty())
-                ConsoleCommand::getCommandMap().erase(it_group++);
-            else
-                ++it_group;
+        }
-        // now the same for the lowercase-map:
-        // iterate through all groups
-        for (std::map<std::string, std::map<std::string, ConsoleCommand*> >::iterator it_group = ConsoleCommand::getCommandMapLC().begin(); it_group != ConsoleCommand::getCommandMapLC().end(); )
+        {
-            // iterate through all commands of each group
-            for (std::map<std::string, ConsoleCommand*>::iterator it_name = it_group->second.begin(); it_name != it_group->second.end(); )
+            {
-                // erase the command
-                if (it_name->second == command)
-                    it_group->second.erase(it_name++);
-                else
-                    ++it_name;
+            }
-            // erase the group if it is empty now
-            if (it_group->second.empty())
-                ConsoleCommand::getCommandMapLC().erase(it_group++);
-            else
-                ++it_group;
+        }
+    }
-    /**
-        @brief Deletes all commands
-    */
-    /* static */ void ConsoleCommand::destroyAll()
+    {
-        // delete entries until the map is empty
-        while (!ConsoleCommand::getCommandMap().empty() && !ConsoleCommand::getCommandMap().begin()->second.empty())
-            delete ConsoleCommand::getCommandMap().begin()->second.begin()->second;
+    }
+}

code/trunk/src/libraries/core/command/ConsoleCommand.h

-                      r9983
+                      r10624
 /**
-    @defgroup ConsoleCommand Console commands
-    @ingroup Command
-*/
-/**
     @file
     @ingroup Command ConsoleCommand
+    @brief Declaration of the orxonox::ConsoleCommand class and the SetConsoleCommand() macro.
+    @anchor ConsoleCommandExample
+    Console commands can be used to write scripts, use key-bindings or simply to be
+    entered into the shell by the user. Instances of orxonox::ConsoleCommand define
+    the function of a command, and also more information like, for example, if it is
+    active, default values, and possible arguments.
+    Commands need to be registered to the system statically on startup by using the
+    SetConsoleCommand() or DeclareConsoleCommand() macros outside of a function.
+    This ensures that commands are known to the system at any time, so they can be
+    evaluated (see orxonox::CommandExecutor::evaluate()), for example for key-bindings.
+    Example:
+    @code
+    void myCoutFunction(const std::string& text)        // Define a static function
+    {
+        orxout() << "Text: " << text << endl;           // Print the text to the console
+    }
+    SetConsoleCommand("cout", &myCoutFunction);         // Register the function as command with name "cout"
+    @endcode
+    Now you can open the shell and execute the command:
+    @code
+    $ cout Hello World
+    @endcode
+    Internally this command is now passed to orxonox::CommandExecutor::execute():
+    @code
+    CommandExecutor::execute("cout HelloWorld");
+    @endcode
+    CommandExecutor searches for a command with name "cout" and passes the arguments
+    "Hello World" to it. Because we registered myCoutFunction() with this command,
+    as a result the following text will be printed to the console:
+    @code
+    Text: Hello World
+    @endcode
+    You can add more attributes to the ConsoleCommand, by using the command-chain feature
+    of SetConsoleCommand(). For example like this:
+    @code
+    SetConsoleCommand("cout", &myCoutFunction)
+        .addGroup("output", "text")
+        .accessLevel(AccessLevel::Offline)
+        .defaultValues("no text");
+    @endcode
+    Open the shell again and try it:
+    @code
+    $ cout Hello World
+    Text: Hello World
+    $ output text Hello World
+    Text: Hello World
+    $ cout
+    Text: no text
+    @endcode
+    If you execute it online (note: the access level is "Offline"), you will see the
+    following (or something similar):
+    @code
+    $ cout Hello World
+    Error: Can't execute command "cout", access denied.
+    @endcode
+    If a command is executed, the arguments are passed to an underlying function,
+    whitch is wrapped by an orxonox::Functor which again is wrapped by an orxonox::Executor.
+    The Functor contains the function-pointer, as well as the object-pointer in
+    case of a non-static member-function. The executor stores possible default-values
+    for each argument of the function.
+    The function of a command can be changed at any time. It's possible to just exchange
+    the function-pointer of the underlying Functor if the headers of the functions are
+    exactly the same. But you can also exchange the Functor itself or even completely
+    replace the Executor. Also the other attributes of a ConsoleCommand can be modified
+    during the game, for example it can be activated or deactivated.
+    To do so, the function ModifyConsoleCommand() has to be used. It returns an instance
+    of orxonox::ConsoleCommand::ConsoleCommandManipulator which has an interface similar to
+    orxonox::ConsoleCommand, but with slight differences. You can use it the same way like
+    SetConsoleCommand(), meaning you can use command-chains to change different attributes at
+    the same time. ModifyConsoleCommand() must not be executed statically, but rather in a
+    function at some point of the execution of the program.
+    Example:
+    @code
+    void myOtherCoutFunction(const std::string& text)                       // Define a new static function
+    {
+        orxout() << "Uppercase: " << getUppercase(text) << endl;            // Print the text in uppercase to the console
+    }
+    {
+        // ...                                                              // somewhere in the code
+        ModifyConsoleCommand("cout").setFunction(&myOtherCoutFunction);     // Modify the underlying function of the command
+        // ...
+    }
+    @endcode
+    If you now enter the command into the shell, you'll see a different behavior:
+    @code
+    $ cout Hello World
+    Uppercase: HELLO WORLD
+    $ cout
+    Uppercase: NO TEXT
+    @endcode
+    A few important notes about changing functions:
+    Instead of changing the function with setFunction(), you can also create a command-stack
+    by using pushFunction() and popFunction(). It's important to note a few things about that,
+    because the underlying structure of Executor and Functor has a few pitfalls:
+     - If you push a new function-pointer, the same executor as before will be used (and, if
+       the headers match, even the same functor can be used, which is very fast)
+     - If you push a new Functor, the same executor as before will be used
+     - If you push a new Executor, everything is changed
+    Note that the executor contains the @b default @b values, so if you just exchange the
+    Functor, the default values remain the same. However if you decide to change the default
+    values at any point of the stack, <b>this will also change the default values on all
+    other stack-levels</b> that share the same executor. If you don't like this behavior,
+    you have to explicitly push a new executor before changing the default values, either by
+    calling pushFunction(executor) or by calling pushFunction(void) which pushes a copy of
+    the current executor to the stack.
+    Another important point are object pointers in case of non-static member-functions.
+    Whenever you set or push a new function, <b>you must add the object pointer again</b>
+    because objects are stored in the Functor which is usually exchanged if you change
+    the function.
+    You can also use a stack for objects, but note that this <b>object-stack is different for each
+    function</b> - so if you set a new function, the object-stack will be cleared. If you push
+    a new function, the old object-stack is stored in the stack, so it can be restored if
+    you pop the function.
+    %DeclareConsoleCommand():
+    Appart from SetConsoleCommand() you can also call DeclareConsoleCommand(). In contrast
+    to SetConsoleCommand(), this doesn't assign a function to the command. Indeed you have
+    to pass a function-pointer to DeclareConsoleCommand(), but it is only used to determine
+    the header of the future command-function. This allows to declare a command statically,
+    thus it's possible to evaluate key-bindings of this command, but the actual function
+    can be assigned at a later point.
+    Example:
+    @code
+    DeclareConsoleCommand("cout", &prototype::void__string);
+    @endcode
+    If you try to execute the command now, you see the following (or something similar):
+    @code
+    $ cout Hello World
+    Error: Can't execute command "cout", command is not active.
+    @endcode
+    You first have to assign a function to use the command:
+    @code
+    {
+        // ...
+        ModifyConsoleCommand("cout").setFunction(&myCoutFunction);
+        // ...
+    }
+    @endcode
+    Now you can use it:
+    @code
+    $ cout Hello World
+    Text: Hello World
+    @endcode
+    Note that the initial function prototype::void__string is defined in the namespace
+    orxonox::prototype. If there's no function with the desired header, you can extend
+    the collection of functions or simply use another function that has the same header.
+    @brief Declaration of the orxonox::ConsoleCommand class.
 */
 …
 #include <vector>
-#include "util/VA_NARGS.h"
 #include "ArgumentCompletionFunctions.h"
 #include "Executor.h"
-/**
-    @brief Defines a console command. The macro is overloaded for 2-4 parameters.
-    This is an overloaded macro. Depending on the number of arguments a different
-    overloaded implementation of the macro will be chosen.
-    Console commands created with SetConsoleCommand() become active immediately and
-    the given function-pointer (and optionally the object) will be used to execute
-    the command.
-*/
-#define SetConsoleCommand(...) \
-    BOOST_PP_EXPAND(BOOST_PP_CAT(SetConsoleCommand, ORXONOX_VA_NARGS(__VA_ARGS__))(__VA_ARGS__))
-/**
-    @brief This macro is executed if you call SetConsoleCommand() with 2 arguments.
-    @param name The name (string) of the console command
-    @param functionpointer The function-pointer of the corresponding command-function
-*/
-#define SetConsoleCommand2(name, functionpointer) \
-    SetConsoleCommandGeneric("", name, orxonox::createFunctor(functionpointer))
-/**
-    @brief This macro is executed if you call SetConsoleCommand() with 3 arguments.
-    @param group The group (string) of the console command
-    @param name The name (string) of the console command
-    @param functionpointer The function-pointer of the corresponding command-function
-*/
-#define SetConsoleCommand3(group, name, functionpointer) \
-    SetConsoleCommandGeneric(group, name, orxonox::createFunctor(functionpointer))
-/**
-    @brief This macro is executed if you call SetConsoleCommand() with 4 arguments.
-    @param group The group (string) of the console command
-    @param name The name (string) of the console command
-    @param functionpointer The function-pointer of the corresponding command-function
-    @param object The object that will be assigned to the command. Used for member-functions.
-*/
-#define SetConsoleCommand4(group, name, functionpointer, object) \
-    SetConsoleCommandGeneric(group, name, orxonox::createFunctor(functionpointer, object))
-/// Internal macro
-#define SetConsoleCommandGeneric(group, name, functor) \
-    static orxonox::ConsoleCommand& BOOST_PP_CAT(__consolecommand_, __UNIQUE_NUMBER__) = (*orxonox::createConsoleCommand(group, name, orxonox::createExecutor(functor)))
-/**
-    @brief Declares a console command. The macro is overloaded for 2-3 parameters.
-    This is an overloaded macro. Depending on the number of arguments a different
-    overloaded implementation of the macro will be chosen.
-    Console commands created with DeclareConsoleCommand() don't use the the given
-    function-pointer to execute the command, it is only used to define the header
-    of the future command-function. The command is inactive until you manually
-    set a function with orxonox::ModifyConsoleCommand(). You can use a different
-    function-pointer than in the final command, as long as it has the same header.
-*/
-#define DeclareConsoleCommand(...) \
-    BOOST_PP_EXPAND(BOOST_PP_CAT(DeclareConsoleCommand, ORXONOX_VA_NARGS(__VA_ARGS__))(__VA_ARGS__))
-/**
-    @brief This macro is executed if you call DeclareConsoleCommand() with 2 arguments.
-    @param name The name (string) of the console command
-    @param functionpointer The function-pointer of an arbitrary function that has the same header as the final function
-*/
-#define DeclareConsoleCommand2(name, functionpointer) \
-    DeclareConsoleCommandGeneric("", name, orxonox::createFunctor(functionpointer))
-/**
-    @brief This macro is executed if you call DeclareConsoleCommand() with 3 arguments.
-    @param group The group (string) of the console command
-    @param name The name (string) of the console command
-    @param functionpointer The function-pointer of an arbitrary function that has the same header as the final function
-*/
-#define DeclareConsoleCommand3(group, name, functionpointer) \
-    DeclareConsoleCommandGeneric(group, name, orxonox::createFunctor(functionpointer))
-/// Internal macro
-#define DeclareConsoleCommandGeneric(group, name, functor) \
-    static orxonox::ConsoleCommand& BOOST_PP_CAT(__consolecommand_, __UNIQUE_NUMBER__) = (*orxonox::createConsoleCommand(group, name, orxonox::createExecutor(functor), false))
 namespace orxonox
 …
         public:
+            /**
+             * @brief Defines the name of a command, consisting of an optional group ("" means no group) and the name itself.
+             */
+            struct CommandName
+            {
+                CommandName(const std::string& group, const std::string& name) : group_(group), name_(name) {}
+                std::string group_;
+                std::string name_;
+            };
             /**
                 @brief Helper class that is used to manipulate console commands.
 …
         public:
+            ConsoleCommand(const std::string& name, const ExecutorPtr& executor, bool bInitialized = true);
             ConsoleCommand(const std::string& group, const std::string& name, const ExecutorPtr& executor, bool bInitialized = true);
             ~ConsoleCommand();
 …
                 { return this; }
+            inline const std::vector<CommandName>& getNames()
+                { return this->names_; }
         private:
+            void init(const std::string& group, const std::string& name, const ExecutorPtr& executor, bool bInitialized);
             bool headersMatch(const FunctorPtr& functor);
             bool headersMatch(const ExecutorPtr& executor);
 …
             AccessLevel::Enum accessLevel_;                                 ///< The access level (the state of the game in which you can access the command)
             std::string baseName_;                                          ///< The name that was first assigned to the command
+            std::vector<CommandName> names_;                                ///< All names and aliases of this command
             FunctorPtr baseFunctor_;                                        ///< The functor that defines the header of the command-function
 …
             LanguageEntryLabel descriptionReturnvalue_;                     ///< A description of the return-value
             LanguageEntryLabel descriptionParam_[MAX_FUNCTOR_ARGUMENTS];    ///< A description for each argument
-        public:
-            /// Returns the map with all groups and commands.
-            static inline const std::map<std::string, std::map<std::string, ConsoleCommand*> >& getCommands()
-                { return ConsoleCommand::getCommandMap(); }
-            /// Returns the map with all groups and commands in lowercase.
-            static inline const std::map<std::string, std::map<std::string, ConsoleCommand*> >& getCommandsLC()
-                { return ConsoleCommand::getCommandMapLC(); }
-            /// Returns a command (shortcut) with given name. @param name The name of the command shortcut @param bPrintError If true, an error is printed if the command doesn't exist
-            static inline ConsoleCommand* getCommand(const std::string& name, bool bPrintError = false)
-                { return ConsoleCommand::getCommand("", name, bPrintError); }
-            /// Returns a command (shortcut) with given name in lowercase. @param name The lowercase name of the command shortcut @param bPrintError If true, an error is printed if the command doesn't exist
-            static inline ConsoleCommand* getCommandLC(const std::string& name, bool bPrintError = false)
-                { return ConsoleCommand::getCommandLC("", name, bPrintError); }
-            static ConsoleCommand* getCommand(const std::string& group, const std::string& name, bool bPrintError = false);
-            static ConsoleCommand* getCommandLC(const std::string& group, const std::string& name, bool bPrintError = false);
-            static void destroyAll();
-        private:
-            static std::map<std::string, std::map<std::string, ConsoleCommand*> >& getCommandMap();
-            static std::map<std::string, std::map<std::string, ConsoleCommand*> >& getCommandMapLC();
-            static void registerCommand(const std::string& group, const std::string& name, ConsoleCommand* command);
-            static void unregisterCommand(ConsoleCommand* command);
     };
-    /**
-        @brief Creates a new ConsoleCommand.
-        @param name The name of the command
-        @param executor The executor of the command
-        @param bInitialized If true, the command is ready to be executed, otherwise it has to be activated first.
-    */
-    inline ConsoleCommand* createConsoleCommand(const std::string& name, const ExecutorPtr& executor, bool bInitialized = true)
-        { return new ConsoleCommand("", name, executor, bInitialized); }
-    /**
-        @brief Creates a new ConsoleCommand.
-        @param group The group of the command
-        @param name The name of the command
-        @param executor The executor of the command
-        @param bInitialized If true, the command is ready to be executed, otherwise it has to be activated first.
-    */
-    inline ConsoleCommand* createConsoleCommand(const std::string& group, const std::string& name, const ExecutorPtr& executor, bool bInitialized = true)
-        { return new ConsoleCommand(group, name, executor, bInitialized); }
-    /**
-        @brief Returns a manipulator for a command with the given name.
-        @note If the command doesn't exist, the manipulator contains a NULL pointer to the command,
-        but it can still be used without checks, because all functions of ConsoleCommandManipulator
-        check internally if the command exists.
-    */
-    inline ConsoleCommand::ConsoleCommandManipulator ModifyConsoleCommand(const std::string& name)
-        { return ConsoleCommand::getCommand(name, true); }
-    /**
-        @brief Returns a manipulator for a command with the given group and name.
-        @note If the command doesn't exist, the manipulator contains a NULL pointer to the command,
-        but it can still be used without checks, because all functions of ConsoleCommandManipulator
-        check internally if the command exists.
-    */
-    inline ConsoleCommand::ConsoleCommandManipulator ModifyConsoleCommand(const std::string& group, const std::string& name)
-        { return ConsoleCommand::getCommand(group, name, true); }
+}

code/trunk/src/libraries/core/command/ConsoleCommandCompilation.cc

r8858	r10624
41	41	#include "util/ExprParser.h"
42	42	#include "util/StringUtils.h"
43		#include "ConsoleCommand.h"
	43	#include "ConsoleCommandIncludes.h"
44	44	#include "CommandExecutor.h"
45	45

code/trunk/src/libraries/core/command/IRC.cc

r8858	r10624
39	39	#include "util/Exception.h"
40	40	#include "util/StringUtils.h"
41		#include "ConsoleCommand.h"
	41	#include "ConsoleCommandIncludes.h"
42	42	#include "TclThreadManager.h"
43	43

code/trunk/src/libraries/core/command/Shell.cc

-                      r9667
+                      r10624
 #include "core/config/ConfigFileManager.h"
 #include "core/config/ConfigValueIncludes.h"
 #include "core/PathConfig.h"
+#include "core/ApplicationPaths.h"
 #include "core/input/InputBuffer.h"
 #include "CommandExecutor.h"
 …
         // Choose the default level according to the path Orxonox was started (build directory or not)
         OutputLevel defaultDebugLevel = (PathConfig::buildDirectoryRun() ? DefaultLogLevel::Dev : DefaultLogLevel::User);
+        OutputLevel defaultDebugLevel = (ApplicationPaths::buildDirectoryRun() ? DefaultLogLevel::Dev : DefaultLogLevel::User);
         this->setLevelMax(defaultDebugLevel);
 …
     void Shell::devModeChanged(bool value)
+    {
         bool isNormal = (value == PathConfig::buildDirectoryRun());
+        bool isNormal = (value == ApplicationPaths::buildDirectoryRun());
         if (isNormal)
+        {

code/trunk/src/libraries/core/command/Shell.h

r9667	r10624
49	49
50	50	#include "util/output/BaseWriter.h"
51		#include "core/Core.h"
	51	#include "core/CoreConfig.h"
52	52
53	53	namespace orxonox

code/trunk/src/libraries/core/command/TclBind.cc

-                      r9550
+                      r10624
 #include "util/Exception.h"
 #include "util/StringUtils.h"
 #include "core/PathConfig.h"
+#include "core/ApplicationPaths.h"
 #include "CommandExecutor.h"
 #include "ConsoleCommand.h"
+#include "ConsoleCommandIncludes.h"
 #include "TclThreadManager.h"
 …
+    {
 #ifdef DEPENDENCY_PACKAGE_ENABLE
         if (PathConfig::buildDirectoryRun())
+        if (ApplicationPaths::buildDirectoryRun())
             return (std::string(specialConfig::dependencyLibraryDirectory) + "/tcl");
         else
             return (PathConfig::getRootPathString() + specialConfig::defaultLibraryPath + "/tcl");
+            return (ApplicationPaths::getRootPathString() + specialConfig::defaultLibraryPath + "/tcl");
 #else
         return "";

code/trunk/src/libraries/core/command/TclThreadManager.cc

r8858	r10624
47	47	#include "core/CoreIncludes.h"
48	48	#include "CommandExecutor.h"
49		#include "ConsoleCommand.h"
	49	#include "ConsoleCommandIncludes.h"
50	50	#include "TclBind.h"
51	51	#include "TclThreadList.h"

code/trunk/src/libraries/core/config/CMakeLists.txt

r9667	r10624
1	1	ADD_SOURCE_FILES(CORE_SRC_FILES
2		~~CommandLineParser.cc~~
3	2	# ConfigFile.cc is already included in FilesystemBuildUnit.cc
4	3	ConfigFileEntryValue.cc

code/trunk/src/libraries/core/config/ConfigFile.cc

-                      r9559
+                      r10624
 #include "util/Convert.h"
 #include "util/StringUtils.h"
 #include "core/PathConfig.h"
+#include "core/ConfigurablePaths.h"
 #include "ConfigFileEntryComment.h"
 #include "ConfigFileEntryValue.h"
 …
         if (!filepath.is_complete())
+        {
             filepath = PathConfig::getConfigPath() / filepath;
+            filepath = ConfigurablePaths::getConfigPath() / filepath;
             if (this->bCopyFallbackFile_)
+            {
 …
                 if (!boost::filesystem::exists(filepath))
+                {
                     boost::filesystem::path defaultFilepath(PathConfig::getDataPath() / DEFAULT_CONFIG_FOLDER / this->filename_);
+                    boost::filesystem::path defaultFilepath(ConfigurablePaths::getDataPath() / DEFAULT_CONFIG_FOLDER / this->filename_);
                     if (boost::filesystem::exists(defaultFilepath))
+                    {
 …
         boost::filesystem::path filepath(filename);
         if (!filepath.is_complete())
             filepath = PathConfig::getConfigPath() / filename;
+            filepath = ConfigurablePaths::getConfigPath() / filename;
         std::ofstream file;
         file.open(filepath.string().c_str(), std::fstream::out);

code/trunk/src/libraries/core/config/Configurable.cc

r9667	r10624
32	32	namespace orxonox
33	33	{
34		RegisterClassNoArgs(Configurable);
	34	RegisterClassNoArgs(Configurable).virtualBase();
35	35
36	36	Configurable::Configurable()

code/trunk/src/libraries/core/config/SettingsConfigFile.cc

r9569	r10624
35	35
36	36	#include "util/StringUtils.h"
37		#include "core/command/ConsoleCommand.h"
	37	#include "core/command/ConsoleCommandIncludes.h"
38	38	#include "ConfigFileManager.h"
39	39	#include "ConfigValueContainer.h"

code/trunk/src/libraries/core/input/InputManager.cc

-                      r9667
+                      r10624
 #include "core/GraphicsManager.h"
 #include "core/config/ConfigValueIncludes.h"
 #include "core/config/CommandLineParser.h"
 #include "core/command/ConsoleCommand.h"
+#include "core/commandline/CommandLineIncludes.h"
+#include "core/command/ConsoleCommandIncludes.h"
 #include "core/command/Functor.h"
 …
         return (lval = (InputManager::State)(lval & rval));
+    }
+    RegisterAbstractClass(InputManager).inheritsFrom<WindowEventListener>();
     // ############################################################

code/trunk/src/libraries/core/input/JoyStick.cc

r9667	r10624
47	47
48	48	std::vector<std::string> JoyStick::deviceNames_s;
	49
	50	RegisterAbstractClass(JoyStick).inheritsFrom<Configurable>();
49	51
50	52	JoyStick::JoyStick(unsigned int id, OIS::InputManager* oisInputManager)

code/trunk/src/libraries/core/input/JoyStickQuantityListener.cc

r9667	r10624
36	36	std::vector<JoyStick*> JoyStickQuantityListener::joyStickList_s;
37	37
	38	RegisterAbstractClass(JoyStickQuantityListener).inheritsFrom<Listable>();
	39
38	40	JoyStickQuantityListener::JoyStickQuantityListener()
39	41	{

code/trunk/src/libraries/core/input/KeyBinder.cc

-                      r9667
+                      r10624
 #include "core/config/ConfigValueIncludes.h"
 #include "core/config/ConfigFile.h"
+#include "core/PathConfig.h"
+#include "core/ApplicationPaths.h"
+#include "core/ConfigurablePaths.h"
 #include "InputCommands.h"
 #include "JoyStick.h"
 …
 namespace orxonox
+{
+    RegisterAbstractClass(KeyBinder).inheritsFrom<JoyStickQuantityListener>();
     /**
     @brief
 …
         orxout(internal_info, context::input) << "KeyBinder: Loading key bindings..." << endl;
         this->configFile_ = new ConfigFile(this->filename_, !PathConfig::buildDirectoryRun());
+        this->configFile_ = new ConfigFile(this->filename_, !ApplicationPaths::buildDirectoryRun());
         this->configFile_->load();
         if (PathConfig::buildDirectoryRun())
+        if (ApplicationPaths::buildDirectoryRun())
+        {
             // Dev users should have combined key bindings files
             std::string defaultFilepath(PathConfig::getDataPathString() + ConfigFile::DEFAULT_CONFIG_FOLDER + '/' + this->filename_);
+            std::string defaultFilepath(ConfigurablePaths::getDataPathString() + ConfigFile::DEFAULT_CONFIG_FOLDER + '/' + this->filename_);
             std::ifstream file(defaultFilepath.c_str());
             if (file.is_open())
 …
             addButtonToCommand(binding, it->second);
             std::string str = binding;
             if (PathConfig::buildDirectoryRun() && binding.empty())
+            if (ApplicationPaths::buildDirectoryRun() && binding.empty())
                 str = "NoBinding";
             it->second->setBinding(this->configFile_, this->fallbackConfigFile_, binding, bTemporary);

code/trunk/src/libraries/core/input/KeyBinderManager.cc

-                      r9667
+                      r10624
 #include "util/Output.h"
 #include "util/Exception.h"
 #include "util/ScopedSingletonManager.h"
+#include "core/singleton/ScopedSingletonIncludes.h"
 #include "core/config/ConfigValueIncludes.h"
 #include "core/CoreIncludes.h"
 #include "core/LuaState.h"
 #include "core/command/ConsoleCommand.h"
+#include "core/command/ConsoleCommandIncludes.h"
 #include "InputManager.h"
 #include "KeyDetector.h"
 …
 namespace orxonox
+{
     ManageScopedSingleton(KeyBinderManager, ScopeID::Graphics, false);
+    ManageScopedSingleton(KeyBinderManager, ScopeID::GRAPHICS, false);
     static const std::string __CC_keybind_name = "keybind";
 …
     SetConsoleCommand(__CC_unbind_name,   &KeyBinderManager::unbind).defaultValues("");
     SetConsoleCommand(__CC_tunbind_name,  &KeyBinderManager::tunbind).defaultValues("");
+    RegisterAbstractClass(KeyBinderManager).inheritsFrom<Configurable>();
     KeyBinderManager::KeyBinderManager()

code/trunk/src/libraries/core/input/KeyDetector.cc

-                      r7284
+                      r10624
 #include "KeyDetector.h"
-#include "util/ScopedSingletonManager.h"
 #include "core/CoreIncludes.h"
+#include "core/command/ConsoleCommand.h"
+#include "core/singleton/ScopedSingletonIncludes.h"
+#include "core/command/ConsoleCommandIncludes.h"
 #include "Button.h"
 #include "InputManager.h"
 …
 namespace orxonox
+{
     ManageScopedSingleton(KeyDetector, ScopeID::Graphics, false);
+    ManageScopedSingleton(KeyDetector, ScopeID::GRAPHICS, false);
     static const std::string __CC_KeyDetector_callback_name = "KeyDetectorKeyPressed";
     DeclareConsoleCommand(__CC_KeyDetector_callback_name, &prototype::void__string).hide();
+    RegisterAbstractClass(KeyDetector).inheritsFrom<KeyBinder>();
     KeyDetector::KeyDetector()

code/trunk/src/libraries/core/input/Mouse.cc

-                      r9667
+                      r10624
 #include <ois/OISMouse.h>
 #include "core/CoreIncludes.h"
 #include "core/command/ConsoleCommand.h"
+#include "core/command/ConsoleCommandIncludes.h"
 #include "InputState.h"
 …
     SetConsoleCommand(__CC_Mouse_name, __CC_ungrab_name, &Mouse::ungrab);
 #endif
+    RegisterAbstractClass(Mouse).inheritsFrom<WindowEventListener>();
     Mouse::Mouse(unsigned int id, OIS::InputManager* oisInputManager)

code/trunk/src/libraries/core/object/CMakeLists.txt

r9667	r10624
2	2	Context.cc
3	3	Destroyable.cc
	4	DestroyLaterManager.cc
4	5	Listable.cc
5	6	ObjectListBase.cc

code/trunk/src/libraries/core/object/Context.cc

r9667	r10624
76	76	/static/ void Context::setRootContext(Context* context)
77	77	{
78		~~if (Context::rootContext_s)~~
79		~~delete Context::rootContext_s;~~
80	78	Context::rootContext_s = context;
	79	}
	80
	81	/static/ void Context::destroyRootContext()
	82	{
	83	delete Context::rootContext_s;
	84	Context::rootContext_s = NULL;
81	85	}
82	86
83	87	/static/ Context* Context::getRootContext()
84	88	{
85		if (!Context::rootContext_s)
86		Context::rootContext_s = new Context(NULL);
	89	OrxVerify(Context::rootContext_s != NULL, "Root Context is undefined");
87	90	return Context::rootContext_s;
88	91	}
…	…
97	100	return this->objectLists_[classID];
98	101	}
	102
	103	void Context::destroyObjectList(const Identifier* identifier)
	104	{
	105	ObjectListBase* objectList = this->getObjectList(identifier);
	106	delete objectList;
	107	this->objectLists_[identifier->getClassID()] = NULL;
	108	}
99	109	}

code/trunk/src/libraries/core/object/Context.h

-                      r9667
+                      r10624
         public:
             static void setRootContext(Context* context);
+            static void destroyRootContext();
             static Context* getRootContext();
 …
+            }
+            void destroyObjectList(const Identifier* identifier);
         private:
             Context* parentContext_;

code/trunk/src/libraries/core/object/Destroyable.cc

-                      r9944
+                      r10624
 #include "Destroyable.h"
+#include "DestroyLaterManager.h"
 #include <cassert>
 …
     /**
         @brief Deletes the object if no @ref orxonox::SmartPtr "smart pointers" point to this object. Otherwise schedules the object to be deleted as soon as possible.
         Always call destroy() instead of using 'delete' directly, otherwise smart pointers won't work.
+        @brief Deletes the object if no @ref orxonox::StrongPtr "strong pointers" point to this object. Otherwise schedules the object to be deleted as soon as possible.
+        Always call destroy() instead of using 'delete' directly, otherwise strong pointers won't work.
     */
     void Destroyable::destroy()
 …
+        }
+    }
+    /**
+     * Works like @ref destroy() but doesn't destroy the object until the current tick has ended.
+     */
+    void Destroyable::destroyLater()
+    {
+        // register in DestroyLaterManager - this ensures that a strongPtr points to this object and keeps it alive for a while
+        DestroyLaterManager::getInstance().retain(this);
+        // request destruction -> object will be deleted after all strongPtrs (including the one in DestroyLaterManager) were destroyed.
+        this->destroy();
+    }
+}

code/trunk/src/libraries/core/object/Destroyable.h

-                      r9944
+                      r10624
     @file
     @ingroup Object
     @brief Declaration of Destroyable, the base class of all objects which can be used with SmartPtr and WeakPtr.
+    @brief Declaration of Destroyable, the base class of all objects which can be used with StrongPtr and WeakPtr.
 */
 …
+{
     /**
         @brief Classes must inherit from this class if they should be used with SmartPtr or WeakPtr.
+        @brief Classes must inherit from this class if they should be used with StrongPtr or WeakPtr.
     */
     class _CoreExport Destroyable
+    {
         template <class T>
         friend class SmartPtr;
+        friend class StrongPtr;
         friend class DestructionListener;
 …
             void destroy();
+            void destroyLater();
             /// Returns the number of @ref orxonox::SmartPtr "smart pointers" that point to this object.
+            /// Returns the number of @ref orxonox::StrongPtr "strong pointers" that point to this object.
             inline unsigned int getReferenceCount() const
                 { return this->referenceCount_; }
         protected:
             /// This virtual function is called if destroy() is called and no SmartPtr points to this object. Used in some cases to create a new SmartPtr to
+            /// This virtual function is called if destroy() is called and no StrongPtr points to this object. Used in some cases to create a new StrongPtr to
             /// prevent destruction. Don't call this function directly - use destroy() instead.
             virtual void preDestroy() {}
         private:
             /// Increments the reference counter (for smart pointers).
+            /// Increments the reference counter (for strong pointers).
             inline void incrementReferenceCount()
                 { ++this->referenceCount_; }
             /// Decrements the reference counter (for smart pointers).
+            /// Decrements the reference counter (for strong pointers).
             inline void decrementReferenceCount()
+            {
 …
                 { this->destructionListeners_.erase(pointer); }
             int referenceCount_;                                    //!< Counts the references from smart pointers to this object
+            int referenceCount_;                                    //!< Counts the references from strong pointers to this object
             bool requestedDestruction_;                             //!< Becomes true after someone called delete on this object
             std::set<DestructionListener*> destructionListeners_;   //!< All destruction listeners (for example weak pointers which point to this object and like to get notified if it dies)

code/trunk/src/libraries/core/object/Iterator.h

-                      r9667
+                      r10624
                 @brief Constructor: Sets the element, whereon the iterator points, to zero.
             */
             inline Iterator() : IteratorBase<T, Iterator<T> >(NULL) {}
+            inline Iterator() : IteratorBase<T, Iterator<T> >() {}
             /**
 …
                 @param other The other Iterator
             */
             inline Iterator(const Iterator<T>& other) : IteratorBase<T, Iterator<T> >(other) {}
+            inline Iterator(const IteratorBase<T, Iterator<T> >& other) : IteratorBase<T, Iterator<T> >(other) {}
             /**

code/trunk/src/libraries/core/object/IteratorBase.h

-                      r9667
+                      r10624
 #include "core/CorePrereqs.h"
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_base_of.hpp>
 #include "ObjectListBase.h"
 …
     class IteratorBase : public ObjectListElementRemovalListener
+    {
+        BOOST_STATIC_ASSERT((boost::is_base_of<Listable, T>::value));
+        protected:
+            /**
+                @brief Constructor: Sets the element, whereon the iterator points, to the given element.
+                This constructor is protected and only for internal usage (don't mess with the BaseElements directly).
+            */
+            inline IteratorBase(ObjectListBaseElement* element = NULL)
+            {
+                this->element_ = element;
+                this->registerIterator();
+            }
         public:
             /**
+                @brief Constructor: Sets the element, whereon the iterator points, to zero.
+            */
+            inline IteratorBase(ObjectListBaseElement* element)
+            {
+                @brief Constructor: Sets the element, whereon the iterator points, to the given element.
+            */
+            inline IteratorBase(ObjectListElement<T>* element)
+            {
+                this->element_ = element;
+                this->registerIterator();
+            }
+            /**
+                @brief Constructor: Sets the element, whereon the iterator points, to the given element of another type.
+                The element's type O must be a derivative of the Iterator's type T.
+            */
+            template <class O>
+            inline IteratorBase(ObjectListElement<O>* element)
+            {
+                (void)static_cast<T*>((O*)NULL); // Check type: The element's type O must be a derivative of the Iterator's type T.
                 this->element_ = element;
                 this->registerIterator();

code/trunk/src/libraries/core/object/Listable.cc

r9667	r10624
39	39	namespace orxonox
40	40	{
41		RegisterClass(Listable);
	41	RegisterClass(Listable).virtualBase();
42	42
43	43	/**

code/trunk/src/libraries/core/object/ObjectList.h

-                      r9667
+                      r10624
 #include "core/CorePrereqs.h"
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_base_of.hpp>
 #include "ObjectListBase.h"
 #include "ObjectListIterator.h"
 …
     class ObjectList
+    {
+        BOOST_STATIC_ASSERT((boost::is_base_of<Listable, T>::value));
         public:
             typedef ObjectListIterator<T> iterator;
+            /// Returns the size of the list (for the root context)
+            inline static size_t size()
+            {   return size(Context::getRootContext());   }
             /// Returns the size of the list
             inline static size_t size()
+            inline static size_t size(Context* context)
+            {
                 return Context::getRootContext()->getObjectList<T>()->size();
+                return context->getObjectList<T>()->size();
+            }
+            /// Returns an Iterator to the first element in the list (for the root context).
+            inline static ObjectListElement<T>* begin()
+            {   return begin(Context::getRootContext());   }
             /// Returns an Iterator to the first element in the list.
             inline static ObjectListElement<T>* begin()
+            inline static ObjectListElement<T>* begin(Context* context)
+            {
                 ObjectListBase* list = Context::getRootContext()->getObjectList<T>();
+                ObjectListBase* list = context->getObjectList<T>();
                 return static_cast<ObjectListElement<T>*>(list->begin());
+            }
+            /// Returns an Iterator to the element after the last element in the list (for the root context).
+            inline static ObjectListElement<T>* end()
+            {   return end(Context::getRootContext());   }
             /// Returns an Iterator to the element after the last element in the list.
             inline static ObjectListElement<T>* end()
+            inline static ObjectListElement<T>* end(Context* context)
+            {
                 ObjectListBase* list = Context::getRootContext()->getObjectList<T>();
+                ObjectListBase* list = context->getObjectList<T>();
                 return static_cast<ObjectListElement<T>*>(list->end());
+            }
+            /// Returns an Iterator to the last element in the list (for the root context).
+            inline static ObjectListElement<T>* rbegin()
+            {   return rbegin(Context::getRootContext());   }
             /// Returns an Iterator to the last element in the list.
             inline static ObjectListElement<T>* rbegin()
+            inline static ObjectListElement<T>* rbegin(Context* context)
+            {
                 ObjectListBase* list = Context::getRootContext()->getObjectList<T>();
+                ObjectListBase* list = context->getObjectList<T>();
                 return static_cast<ObjectListElement<T>*>(list->rbegin());
+            }
+            /// Returns an Iterator to the element before the first element in the list (for the root context).
+            inline static ObjectListElement<T>* rend()
+            {   return rend(Context::getRootContext());   }
             /// Returns an Iterator to the element before the first element in the list.
             inline static ObjectListElement<T>* rend()
+            inline static ObjectListElement<T>* rend(Context* context)
+            {
                 ObjectListBase* list = Context::getRootContext()->getObjectList<T>();
+                ObjectListBase* list = context->getObjectList<T>();
                 return static_cast<ObjectListElement<T>*>(list->rend());
+            }

code/trunk/src/libraries/core/object/ObjectListIterator.h

r9667	r10624
74	74	@brief Constructor: Sets the element, whereon the ObjectListIterator points, to zero.
75	75	*/
76		inline ObjectListIterator() : IteratorBase<T, ObjectListIterator<T> >(~~NULL~~) {}
	76	inline ObjectListIterator() : IteratorBase<T, ObjectListIterator<T> >() {}
77	77
78	78	/**

code/trunk/src/libraries/core/object/WeakPtr.h

-                      r9571
+                      r10624
+            }
-            /// Constructor: Used to explicitly initialize the weak pointer with a null pointer
-            inline WeakPtr(int) : pointer_(0), base_(0), callback_(0)
+            {
+            }
             /// Constructor: Initializes the weak pointer with a pointer to an object.
             inline WeakPtr(T* pointer) : pointer_(pointer), base_(pointer), callback_(0)
 …
+            {
                 this->unregisterAsDestructionListener(this->base_);
+            }
-            /// Used to assign a null pointer.
-            inline WeakPtr& operator=(int)
+            {
-                WeakPtr(0).swap(*this);
-                return *this;
+            }

Context Navigation

Legend:

Download in other formats: