Changeset 3370

code/trunk

Property svn:mergeinfo changed
/code/branches/resource (added) merged: 3328,3336-3340,3342-3350,3352-3366

code/trunk/cmake/Media.cmake

-                      r2721
+                      r3370
 ################ Installation #################
-# Try no to copy both tcl script file libraries
-IF(TCL_LIBRARY MATCHES "85|8\\.5")
-  SET(TCL_EXCLUDE_PATTERN "tcl8\\.4")
-ELSEIF(TCL_LIBRARY MATCHES "84|8\\.4")
-  SET(TCL_EXCLUDE_PATTERN "tcl8\\.5")
-ENDIF()
 INSTALL(
   DIRECTORY ${CMAKE_MEDIA_OUTPUT_DIRECTORY}/
   DESTINATION ${ORXONOX_MEDIA_INSTALL_PATH}
   REGEX "\\.svn$|_svn$|backToPNG|${TCL_EXCLUDE_PATTERN}" EXCLUDE
+  REGEX "\\.svn$|_svn$|backToPNG" EXCLUDE
+)

code/trunk/cmake/PackageConfig.cmake

-                      r3309
+                      r3370
 # MAJOR: Interface breaking change somewhere (library version changed, etc.)
 # MINOR: Bug fix or small conformant changes
 SET(DEPENDENCY_VERSION_REQUIRED 2)
+SET(DEPENDENCY_VERSION_REQUIRED 3)
 IF(NOT EXISTS ${DEPENDENCY_PACKAGE_DIR}/version.txt)
   SET(DEPENDENCY_VERSION 1.0)
 …
 # Include paths and other special treatments
 SET(ENV{ALUTDIR}               ${DEP_INCLUDE_DIR}/freealut-1.1.0)
 SET(ENV{BOOST_ROOT}            ${DEP_INCLUDE_DIR}/boost-1.39.0)
 SET(ENV{CEGUIDIR}              ${DEP_INCLUDE_DIR}/cegui-0.6.2)
 SET(ENV{DXSDK_DIR}             ${DEP_INCLUDE_DIR}/directx-2007.aug)
 SET(ENV{ENETDIR}               ${DEP_INCLUDE_DIR}/enet-1.2)
 SET(ENV{LUA_DIR}               ${DEP_INCLUDE_DIR}/lua-5.1.4)
 SET(ENV{OGGDIR}                ${DEP_INCLUDE_DIR}/libogg-1.1.3)
 SET(ENV{VORBISDIR}             ${DEP_INCLUDE_DIR}/libvorbis-1.2.0)
 SET(ENV{OGRE_HOME}             ${DEP_INCLUDE_DIR}/ogre-1.4.9)
+SET(ENV{ALUTDIR}               ${DEP_INCLUDE_DIR}/freealut)
+SET(ENV{BOOST_ROOT}            ${DEP_INCLUDE_DIR}/boost)
+SET(ENV{CEGUIDIR}              ${DEP_INCLUDE_DIR}/cegui)
+SET(ENV{DXSDK_DIR}             ${DEP_INCLUDE_DIR}/directx)
+SET(ENV{ENETDIR}               ${DEP_INCLUDE_DIR}/enet)
+SET(ENV{LUA_DIR}               ${DEP_INCLUDE_DIR}/lua)
+SET(ENV{OGGDIR}                ${DEP_INCLUDE_DIR}/libogg)
+SET(ENV{VORBISDIR}             ${DEP_INCLUDE_DIR}/libvorbis)
+SET(ENV{OGRE_HOME}             ${DEP_INCLUDE_DIR}/ogre)
 SET(ENV{OGRE_PLUGIN_DIR}       ${DEP_BINARY_DIR})
 SET(ENV{OPENALDIR}             ${DEP_INCLUDE_DIR}/openal-1.1)
 LIST(APPEND CMAKE_INCLUDE_PATH ${DEP_INCLUDE_DIR}/tcl-8.5.2/include)
 LIST(APPEND CMAKE_INCLUDE_PATH ${DEP_INCLUDE_DIR}/zlib-1.2.3/include)
+SET(ENV{OPENALDIR}             ${DEP_INCLUDE_DIR}/openal)
+LIST(APPEND CMAKE_INCLUDE_PATH ${DEP_INCLUDE_DIR}/tcl/include)
+LIST(APPEND CMAKE_INCLUDE_PATH ${DEP_INCLUDE_DIR}/zlib/include)
 ### INSTALL ###
+# Tcl script library
+INSTALL(
+  DIRECTORY ${DEP_LIBRARY_DIR}/tcl/
+  DESTINATION lib/tcl
+)
 # On Windows, DLLs have to be in the executable folder, install them
 IF(WIN32 AND DEP_BINARY_DIR)

code/trunk/cmake/PackageConfigMSVC.cmake

-                      r3196
+                      r3370
   # Visual Leak Detector
   SET(VLD_INCLUDE_DIR  ${DEP_INCLUDE_DIR}/vld-1.9h CACHE PATH "")
   SET(VLD_LIBRARY_DIR  ${DEP_LIBRARY_DIR}          CACHE PATH "")
+  SET(VLD_INCLUDE_DIR  ${DEP_INCLUDE_DIR}/vld   CACHE PATH "")
+  SET(VLD_LIBRARY_DIR  ${DEP_LIBRARY_DIR}       CACHE PATH "")
   LINK_DIRECTORIES(${VLD_LIBRARY_DIR}) # Used for auto-linking
   MARK_AS_ADVANCED(VLD_INCLUDE_DIR VLD_LIBRARY_DIR)

code/trunk/src/SpecialConfig.h.in

-                      r3196
+                      r3370
     const char ORXONOX_LOG_DEV_PATH[]         = "@CMAKE_LOG_OUTPUT_DIRECTORY@";
 #endif
+    /* OGRE Plugins */
+#ifdef DEPENDENCY_PACKAGE_ENABLE
+    const char ORXONOX_DEP_LIB_PATH[]         = "@DEP_LIBRARY_DIR@";
+#endif
+    // OGRE PLUGINS
 #ifdef NDEBUG
     const char ORXONOX_OGRE_PLUGINS[] = "@OGRE_PLUGINS_RELEASE@";

code/trunk/src/core/CMakeLists.txt

-                      r3327
+                      r3370
   GameMode.cc
   GameState.cc
+  GraphicsManager.cc
+  GUIManager.cc
   Language.cc
   LuaBind.cc
 …
   LINK_LIBRARIES
     ${OGRE_LIBRARY}
+    ${Boost_FILESYSTEM_LIBRARY}
+    ${Boost_SYSTEM_LIBRARY} # Filesystem dependency
     ${Boost_THREAD_LIBRARY}
     ${Boost_FILESYSTEM_LIBRARY}
     ${Boost_SYSTEM_LIBRARY}
     ${Boost_DATE_TIME_LIBRARY} # MSVC only
+    ${Boost_DATE_TIME_LIBRARY} # Thread dependency
+    ${CEGUI_LIBRARY}
+    ${CEGUILUA_LIBRARY}
     ${LUA_LIBRARIES}
     cpptcl_orxonox
+    ogreceguirenderer_orxonox
     ois_orxonox
     tinyxml++_orxonox

code/trunk/src/core/Clock.h

-                      r3196
+                      r3370
+ *
  */
-/**
-    @file
-    @brief Declaration of the Core class.
-    The Core class is a singleton, only used to configure some variables
-    in the core through the config-file.
-*/
 #ifndef _Clock_H__

code/trunk/src/core/ConfigFileManager.cc

-                      r3301
+                      r3370
     const char* const DEFAULT_CONFIG_FILE = "default.ini";
     ConfigFileManager* ConfigFileManager::singletonRef_s = 0;
+    ConfigFileManager* ConfigFileManager::singletonPtr_s = 0;
     SetConsoleCommandShortcutExtern(config).argumentCompleter(0, autocompletion::configvalueclasses()).argumentCompleter(1, autocompletion::configvalues()).argumentCompleter(2, autocompletion::configvalue());
 …
          : mininmalFreeType_(ConfigFileType::numberOfReservedTypes)
+    {
-        assert(singletonRef_s == 0);
-        singletonRef_s = this;
+    }
 …
         for(std::map<ConfigFileType, ConfigFile*>::const_iterator it = this->configFiles_.begin(); it != this->configFiles_.end(); )
             delete (it++)->second;
-        assert(singletonRef_s != 0);
-        singletonRef_s = 0;
+    }

code/trunk/src/core/ConfigFileManager.h

-                      r3196
+                      r3370
 #include "util/OrxEnum.h"
+#include "util/Singleton.h"
 namespace orxonox
 …
     // ConfigFileManager //
     ///////////////////////
+    class _CoreExport ConfigFileManager
+    {
+    class _CoreExport ConfigFileManager : public Singleton<ConfigFileManager>
+    {
+        friend class Singleton<ConfigFileManager>;
         public:
             ConfigFileManager();
 …
             void updateConfigValues(ConfigFileType type);
-            static ConfigFileManager& getInstance() { assert(singletonRef_s); return *singletonRef_s; }
         private:
             ConfigFileManager(const ConfigFileManager&);
 …
             unsigned int mininmalFreeType_;
             static ConfigFileManager* singletonRef_s;
+            static ConfigFileManager* singletonPtr_s;
     };
+}

code/trunk/src/core/ConsoleCommandCompilation.cc

r3198	r3370
94	94	if (newline)
95	95	{
96		COUT(0) << ~~text~~ << std::endl;
	96	COUT(0) << stripEnclosingBraces(text) << std::endl;
97	97	}
98	98	else
99	99	{
100		COUT(0) << ~~text~~;
	100	COUT(0) << stripEnclosingBraces(text);
101	101	}
102	102	}

code/trunk/src/core/Core.cc

-                      r3323
+                      r3370
 #include <cstdio>
 #include <boost/filesystem.hpp>
+#include <OgreRenderWindow.h>
 #ifdef ORXONOX_PLATFORM_WINDOWS
 …
 #include "CoreIncludes.h"
 #include "Factory.h"
+#include "GameMode.h"
+#include "GraphicsManager.h"
+#include "GUIManager.h"
 #include "Identifier.h"
 #include "Language.h"
 …
 #include "TclBind.h"
 #include "TclThreadManager.h"
+#include "input/InputManager.h"
 namespace orxonox
+{
     //! Static pointer to the singleton
     Core* Core::singletonRef_s  = 0;
+    Core* Core::singletonPtr_s  = 0;
     SetCommandLineArgument(mediaPath, "").information("Path to the media/data files");
 …
                 .callback(this, &CoreConfiguration::debugLevelChanged);
             SetConfigValue(language_, Language::getLanguage().defaultLanguage_)
+            SetConfigValue(language_, Language::getInstance().defaultLanguage_)
                 .description("The language of the ingame text")
                 .callback(this, &CoreConfiguration::languageChanged);
 …
                 .callback(this, &CoreConfiguration::initializeRandomNumberGenerator);
+            SetConfigValue(mediaPathString_, mediaPath_.string())
+                .description("Relative path to the game data.")
+                .callback(this, &CoreConfiguration::mediaPathChanged);
+            // Only show this config value for development builds
+            if (Core::isDevelopmentRun())
+            {
+                SetConfigValue(mediaPathString_, mediaPath_.string())
+                    .description("Relative path to the game data.")
+                    .callback(this, &CoreConfiguration::mediaPathChanged);
+            }
+        }
 …
+        {
             // Read the translation file after the language was configured
             Language::getLanguage().readTranslatedLanguageFile();
+            Language::getInstance().readTranslatedLanguageFile();
+        }
 …
         void tsetMediaPath(const std::string& path)
+        {
+            ModifyConfigValue(mediaPathString_, tset, path);
+            if (Core::isDevelopmentRun())
+            {
+                ModifyConfigValue(mediaPathString_, tset, path);
+            }
+            else
+            {
+                // Manual 'config' value without the file entry
+                mediaPathString_ = path;
+                this->mediaPathChanged();
+            }
+        }
 …
     Core::Core(const std::string& cmdLine)
+    {
+        if (singletonRef_s != 0)
+        {
+            COUT(0) << "Error: The Core singleton cannot be recreated! Shutting down." << std::endl;
+            abort();
+        }
+        Core::singletonRef_s = this;
+        // We need the variables very soon. But don't configure them yet!
+        this->configuration_ = new CoreConfiguration();
+        // Cleanup guard for identifier destruction (incl. XMLPort, configValues, consoleCommands)
+        : identifierDestroyer_(Identifier::destroyAllIdentifiers)
+        // Cleanup guard for external console commands that don't belong to an Identifier
+        , consoleCommandDestroyer_(CommandExecutor::destroyExternalCommands)
+        , configuration_(new CoreConfiguration()) // Don't yet create config values!
+        , bDevRun_(false)
+        , bGraphicsLoaded_(false)
+    {
         // Parse command line arguments first
         CommandLine::parseCommandLine(cmdLine);
 …
         // create a signal handler (only active for linux)
         // This call is placed as soon as possible, but after the directories are set
         this->signalHandler_ = new SignalHandler();
+        this->signalHandler_.reset(new SignalHandler());
         this->signalHandler_->doCatch(configuration_->executablePath_.string(), Core::getLogPathString() + "orxonox_crash.log");
 …
         // Manage ini files and set the default settings file (usually orxonox.ini)
         this->configFileManager_ = new ConfigFileManager();
+        this->configFileManager_.reset(new ConfigFileManager());
         this->configFileManager_->setFilename(ConfigFileType::Settings,
             CommandLine::getValue("settingsFile").getString());
         // Required as well for the config values
         this->languageInstance_ = new Language();
+        this->languageInstance_.reset(new Language());
         // Do this soon after the ConfigFileManager has been created to open up the
 …
         // Create the lua interface
         this->luaBind_ = new LuaBind();
+        this->luaBind_.reset(new LuaBind());
         // initialise Tcl
         this->tclBind_ = new TclBind(Core::getMediaPathString());
         this->tclThreadManager_ = new TclThreadManager(tclBind_->getTclInterpreter());
+        this->tclBind_.reset(new TclBind(Core::getMediaPathString()));
+        this->tclThreadManager_.reset(new TclThreadManager(tclBind_->getTclInterpreter()));
         // create a shell
         this->shell_ = new Shell();
+        this->shell_.reset(new Shell());
         // creates the class hierarchy for all classes with factories
 …
     /**
+        @brief Sets the bool to true to avoid static functions accessing a deleted object.
+    @brief
+        All destruction code is handled by scoped_ptrs and SimpleScopeGuards.
     */
     Core::~Core()
+    {
+        delete this->shell_;
+        delete this->tclThreadManager_;
+        delete this->tclBind_;
+        delete this->luaBind_;
+        delete this->configuration_;
+        delete this->languageInstance_;
+        delete this->configFileManager_;
+        // Destroy command line arguments
+        CommandLine::destroyAllArguments();
+        // Also delete external console command that don't belong to an Identifier
+        CommandExecutor::destroyExternalCommands();
+        // Clean up class hierarchy stuff (identifiers, XMLPort, configValues, consoleCommand)
+        Identifier::destroyAllIdentifiers();
+        delete this->signalHandler_;
+        // Don't assign singletonRef_s with NULL! Recreation is not supported
+    }
+    void Core::loadGraphics()
+    {
+        if (bGraphicsLoaded_)
+            return;
+        // Load OGRE including the render window
+        scoped_ptr<GraphicsManager> graphicsManager(new GraphicsManager());
+        // The render window width and height are used to set up the mouse movement.
+        size_t windowHnd = 0;
+        graphicsManager->getRenderWindow()->getCustomAttribute("WINDOW", &windowHnd);
+        // Calls the InputManager which sets up the input devices.
+        scoped_ptr<InputManager> inputManager(new InputManager(windowHnd));
+        // load the CEGUI interface
+        guiManager_.reset(new GUIManager(graphicsManager->getRenderWindow()));
+        // Dismiss scoped pointers
+        graphicsManager_.swap(graphicsManager);
+        inputManager_.swap(inputManager);
+        bGraphicsLoaded_ = true;
+    }
+    void Core::unloadGraphics()
+    {
+        if (!bGraphicsLoaded_)
+            return;
+        this->guiManager_.reset();;
+        this->inputManager_.reset();;
+        this->graphicsManager_.reset();
+        bGraphicsLoaded_ = false;
+    }
 …
+    }
+    /*static*/ const boost::filesystem::path& Core::getRootPath()
+    {
+        return getInstance().configuration_->rootPath_;
+    }
+    /*static*/ std::string Core::getRootPathString()
+    {
+        return getInstance().configuration_->rootPath_.string() + '/';
+    }
     /**
     @note
 …
+        {
             COUT(1) << "Running from the build tree." << std::endl;
             Core::isDevBuild_ = true;
+            Core::bDevRun_ = true;
             configuration_->mediaPath_  = ORXONOX_MEDIA_DEV_PATH;
             configuration_->configPath_ = ORXONOX_CONFIG_DEV_PATH;
 …
+    }
+    void Core::update(const Clock& time)
+    {
+        this->tclThreadManager_->update(time);
+    bool Core::preUpdate(const Clock& time) throw()
+    {
+        std::string exceptionMessage;
+        try
+        {
+            if (this->bGraphicsLoaded_)
+            {
+                // process input events
+                this->inputManager_->update(time);
+                // process gui events
+                this->guiManager_->update(time);
+            }
+            // process thread commands
+            this->tclThreadManager_->update(time);
+        }
+        catch (const std::exception& ex)
+        { exceptionMessage = ex.what(); }
+        catch (...)
+        { exceptionMessage = "Unknown exception"; }
+        if (!exceptionMessage.empty())
+        {
+            COUT(0) << "An exception occurred in the Core preUpdate: " << exceptionMessage << std::endl;
+            COUT(0) << "This should really never happen! Closing the program." << std::endl;
+            return false;
+        }
+        return true;
+    }
+    bool Core::postUpdate(const Clock& time) throw()
+    {
+        std::string exceptionMessage;
+        try
+        {
+            if (this->bGraphicsLoaded_)
+            {
+                // Render (doesn't throw)
+                this->graphicsManager_->update(time);
+            }
+        }
+        catch (const std::exception& ex)
+        { exceptionMessage = ex.what(); }
+        catch (...)
+        { exceptionMessage = "Unknown exception"; }
+        if (!exceptionMessage.empty())
+        {
+            COUT(0) << "An exception occurred in the Core postUpdate: " << exceptionMessage << std::endl;
+            COUT(0) << "This should really never happen! Closing the program." << std::endl;
+            return false;
+        }
+        return true;
+    }
+}

code/trunk/src/core/Core.h

-                      r3323
+                      r3370
 #include <cassert>
+#include <boost/scoped_ptr.hpp>
 #include "util/OutputHandler.h"
+#include "util/ScopeGuard.h"
+#include "util/Singleton.h"
 namespace orxonox
+{
     class CoreConfiguration;
+    using boost::scoped_ptr;
     /**
 …
         The class provides information about the media, config and log path.
         It determines those by the use of platform specific functions.
+    @remark
+        You should only create this singleton once because it destroys the identifiers!
     */
     class _CoreExport Core
+    class _CoreExport Core : public Singleton<Core>
+    {
+        typedef Loki::ScopeGuardImpl0<void (*)()> SimpleScopeGuard;
+        friend class Singleton<Core>;
         public:
             /**
 …
             void setConfigValues();
+            void update(const Clock& time);
+            bool preUpdate(const Clock& time) throw();
+            bool postUpdate(const Clock& time) throw();
+            static Core& getInstance() { assert(Core::singletonRef_s); return *Core::singletonRef_s; }
+            void loadGraphics();
+            void unloadGraphics();
             static int   getSoftDebugLevel(OutputHandler::OutputDevice device = OutputHandler::LD_All);
 …
             //! Returns the path to the log files as boost::filesystem::path
             static const boost::filesystem::path& getLogPath();
+            //! Returns the path to the root folder as boost::filesystem::path
+            static const boost::filesystem::path& getRootPath();
             //! Returns the path to the data files as std::string
             static std::string getMediaPathString();
 …
             //! Returns the path to the log files as std::string
             static std::string getLogPathString();
+            //! Returns the path to the root folder as std::string
+            static std::string getRootPathString();
+            static bool isDevelopmentRun() { return getInstance().bDevRun_; }
         private:
 …
             void setThreadAffinity(int limitToCPU);
+            // Singletons
+            ConfigFileManager*    configFileManager_;
+            Language*             languageInstance_;
+            LuaBind*              luaBind_;
+            Shell*                shell_;
+            SignalHandler*        signalHandler_;
+            TclBind*              tclBind_;
+            TclThreadManager*     tclThreadManager_;
+            // Mind the order for the destruction!
+            scoped_ptr<SignalHandler>     signalHandler_;
+            SimpleScopeGuard              identifierDestroyer_;
+            SimpleScopeGuard              consoleCommandDestroyer_;
+            scoped_ptr<ConfigFileManager> configFileManager_;
+            scoped_ptr<Language>          languageInstance_;
+            scoped_ptr<CoreConfiguration> configuration_;
+            scoped_ptr<LuaBind>           luaBind_;
+            scoped_ptr<TclBind>           tclBind_;
+            scoped_ptr<TclThreadManager>  tclThreadManager_;
+            scoped_ptr<Shell>             shell_;
+            // graphical
+            scoped_ptr<GraphicsManager>   graphicsManager_;     //!< Interface to OGRE
+            scoped_ptr<InputManager>      inputManager_;        //!< Interface to OIS
+            scoped_ptr<GUIManager>        guiManager_;          //!< Interface to GUI
             bool isDevBuild_;                               //!< True for builds in the build directory (not installed)
             CoreConfiguration*    configuration_;
+            bool                          bDevRun_;             //!< True for runs in the build directory (not installed)
+            bool                          bGraphicsLoaded_;
             static Core* singletonRef_s;
+            static Core* singletonPtr_s;
     };
+}

code/trunk/src/core/CorePrereqs.h

-                      r3327
+                      r3370
     class FunctorMember;
     class FunctorStatic;
+    class GraphicsManager;
+    class GUIManager;
     class Identifier;
     class IRC;
 …
     template <class T>
     class ObjectListIterator;
+    class OgreWindowEventListener;
     class OrxonoxClass;
     class Shell;
 …
     // game states
     class Game;
-    struct GameStateConstrParams;
     class GameState;
+    struct GameStateInfo;
     struct GameStateTreeNode;
 …
+}
+// CEGUI
+namespace CEGUI
+{
+    class DefaultLogger;
+    class Logger;
+    class LuaScriptModule;
+    class OgreCEGUIRenderer;
+    class OgreCEGUIResourceProvider;
+    class OgreCEGUITexture;
+}
+// Lua
+struct lua_State;
 // TinyXML and TinyXML++
 class TiXmlString;

code/trunk/src/core/Game.cc

-                      r3323
+                      r3370
 #include "util/Debug.h"
 #include "util/Exception.h"
+#include "util/ScopeGuard.h"
 #include "util/Sleep.h"
 #include "util/SubString.h"
 …
 #include "CoreIncludes.h"
 #include "ConfigValueIncludes.h"
+#include "GameMode.h"
 #include "GameState.h"
 …
     SetConsoleCommandShortcutExternAlias(stop_game, "exit");
     std::map<std::string, Game::GameStateInfo> Game::gameStateDeclarations_s;
     Game* Game::singletonRef_s = 0;
+    std::map<std::string, GameStateInfo> Game::gameStateDeclarations_s;
+    Game* Game::singletonPtr_s = 0;
 …
     struct GameStateTreeNode
+    {
         GameState* state_;
+        std::string name_;
         weak_ptr<GameStateTreeNode> parent_;
         std::vector<shared_ptr<GameStateTreeNode> > children_;
 …
     Game::Game(const std::string& cmdLine)
+    {
-        if (singletonRef_s != 0)
+        {
-            COUT(0) << "Error: The Game singleton cannot be recreated! Shutting down." << std::endl;
-            abort();
+        }
-        singletonRef_s = this;
         this->bAbort_ = false;
         bChangingState_ = false;
+#ifdef ORXONOX_PLATFORM_WINDOWS
+        minimumSleepTime_ = 1000/*us*/;
+#else
+        minimumSleepTime_ = 0/*us*/;
+#endif
         // Create an empty root state
+        declareGameState<GameState>("GameState", "emptyRootGameState", true, false);
+        // reset statistics
+        this->statisticsStartTime_ = 0;
+        this->statisticsTickTimes_.clear();
+        this->periodTickTime_ = 0;
+        this->periodTime_ = 0;
+        this->avgFPS_ = 0.0f;
+        this->avgTickTime_ = 0.0f;
+        this->declareGameState<GameState>("GameState", "emptyRootGameState", true, false);
         // Set up a basic clock to keep time
         this->gameClock_ = new Clock();
+        this->gameClock_.reset(new Clock());
         // Create the Core
         this->core_ = new Core(cmdLine);
         // After the core has been created, we can safely instantiate the GameStates
+        this->core_.reset(new Core(cmdLine));
+        // After the core has been created, we can safely instantiate the GameStates that don't require graphics
         for (std::map<std::string, GameStateInfo>::const_iterator it = gameStateDeclarations_s.begin();
             it != gameStateDeclarations_s.end(); ++it)
+        {
+            // Only create the states appropriate for the game mode
+            //if (GameMode::showsGraphics || !it->second.bGraphicsMode)
+            GameStateConstrParams params = { it->second.stateName, it->second.bIgnoreTickTime };
+            gameStates_[getLowercase(it->second.stateName)] = GameStateFactory::fabricate(it->second.className, params);
+            if (!it->second.bGraphicsMode)
+                constructedStates_[it->second.stateName] = GameStateFactory::fabricate(it->second);
+        }
         // The empty root state is ALWAYS loaded!
         this->rootStateNode_ = shared_ptr<GameStateTreeNode>(new GameStateTreeNode());
         this->rootStateNode_->state_ = getState("emptyRootGameState");
         this->activeStateNode_ = this->rootStateNode_;
         this->activeStates_.push_back(this->rootStateNode_->state_);
+        this->rootStateNode_->name_ = "emptyRootGameState";
+        this->loadedTopStateNode_ = this->rootStateNode_;
+        this->loadedStates_.push_back(this->getState(rootStateNode_->name_));
         // Do this after the Core creation!
         this->configuration_ = new GameConfiguration();
+        this->configuration_.reset(new GameConfiguration());
+    }
     /**
     @brief
+        All destruction code is handled by scoped_ptrs and SimpleScopeGuards.
     */
     Game::~Game()
+    {
-        // Destroy the configuration helper class instance
-        delete this->configuration_;
-        // Destroy the GameStates (note that the nodes still point to them, but doesn't matter)
-        for (std::map<std::string, GameState*>::const_iterator it = gameStates_.begin();
-            it != gameStates_.end(); ++it)
-            delete it->second;
-        // Destroy the Core and with it almost everything
-        delete this->core_;
-        delete this->gameClock_;
-        // Take care of the GameStateFactories
-        GameStateFactory::destroyFactories();
-        // Don't assign singletonRef_s with NULL! Recreation is not supported
+    }
 …
             COUT(0) << "Warning: Starting game without requesting GameState. This automatically terminates the program." << std::endl;
+        // reset statistics
+        this->statisticsStartTime_ = 0;
+        this->statisticsTickTimes_.clear();
+        this->periodTickTime_ = 0;
+        this->periodTime_ = 0;
+        this->avgFPS_ = 0.0f;
+        this->avgTickTime_ = 0.0f;
+        this->excessSleepTime_ = 0;
         // START GAME
         // first delta time should be about 0 seconds
 …
         StatisticsTickInfo tickInfo = {0, 0};
         statisticsTickTimes_.push_back(tickInfo);
+        while (!this->bAbort_ && (!this->activeStates_.empty() || this->requestedStateNodes_.size() > 0))
+        {
+            uint64_t currentTime = this->gameClock_->getRealMicroseconds();
+            uint64_t nextTickTime = statisticsTickTimes_.back().tickTime + static_cast<uint64_t>(1000000.0f / configuration_->fpsLimit_);
+            if (currentTime < nextTickTime)
+            {
+                usleep(nextTickTime - currentTime);
+                continue;
+            }
+        while (!this->bAbort_ && (!this->loadedStates_.empty() || this->requestedStateNodes_.size() > 0))
+        {
+            // Generate the dt
             this->gameClock_->capture();
             // STATISTICS
             StatisticsTickInfo tickInfo = {currentTime, 0};
+            // Statistics init
+            StatisticsTickInfo tickInfo = {gameClock_->getMicroseconds(), 0};
             statisticsTickTimes_.push_back(tickInfo);
             this->periodTime_ += this->gameClock_->getDeltaTimeMicroseconds();
+            // UPDATE STATE STACK
+            while (this->requestedStateNodes_.size() > 0)
+            {
+                shared_ptr<GameStateTreeNode> requestedStateNode = this->requestedStateNodes_.front();
+                assert(this->activeStateNode_);
+                if (!this->activeStateNode_->parent_.expired() && requestedStateNode == this->activeStateNode_->parent_.lock())
+                    this->unloadState(this->activeStateNode_->state_);
+                else // has to be child
+                {
+                    try
+                    {
+                        this->loadState(requestedStateNode->state_);
+                    }
+                    catch (const std::exception& ex)
+                    {
+                        COUT(1) << "Error: Loading GameState '" << requestedStateNode->state_->getName() << "' failed: " << ex.what() << std::endl;
+                        // All scheduled operations have now been rendered inert --> flush them and issue a warning
+                        if (this->requestedStateNodes_.size() > 1)
+                            COUT(1) << "All " << this->requestedStateNodes_.size() - 1 << " scheduled transitions have been ignored." << std::endl;
+                        this->requestedStateNodes_.clear();
+                        break;
+                    }
+                }
+                this->activeStateNode_ = requestedStateNode;
+                this->requestedStateNodes_.erase(this->requestedStateNodes_.begin());
+            }
+            // UPDATE, Core first
+            bool threwException = false;
+            try
+            {
+                this->core_->update(*this->gameClock_);
+            }
+            catch (const std::exception& ex)
+            {
+                threwException = true;
+                COUT(0) << "Exception while ticking the Core: " << ex.what() << std::endl;
+            }
+            catch (...)
+            {
+                threwException = true;
+            }
+            if (threwException)
+            {
+                COUT(0) << "An exception occured while ticking the Core. This should really never happen!" << std::endl;
+                COUT(0) << "Closing the program." << std::endl;
+            // Update the GameState stack if required
+            this->updateGameStateStack();
+            // Core preUpdate (doesn't throw)
+            if (!this->core_->preUpdate(*this->gameClock_))
+            {
                 this->stop();
                 break;
+            }
+            // UPDATE, GameStates bottom to top in the stack
+            // Note: The first element is the empty root state, which doesn't need ticking
+            for (std::vector<GameState*>::const_iterator it = this->activeStates_.begin() + 1;
+                it != this->activeStates_.end(); ++it)
+            {
+                bool threwException = false;
+            // Update the GameStates bottom up in the stack
+            this->updateGameStates();
+            // Core postUpdate (doesn't throw)
+            if (!this->core_->postUpdate(*this->gameClock_))
+            {
+                this->stop();
+                break;
+            }
+            // Evaluate statistics
+            this->updateStatistics();
+            // Limit framerate
+            this->updateFPSLimiter();
+        }
+        // UNLOAD all remaining states
+        while (this->loadedStates_.size() > 1)
+            this->unloadState(this->loadedStates_.back()->getName());
+        this->loadedTopStateNode_ = this->rootStateNode_;
+        this->requestedStateNodes_.clear();
+    }
+    void Game::updateGameStateStack()
+    {
+        while (this->requestedStateNodes_.size() > 0)
+        {
+            shared_ptr<GameStateTreeNode> requestedStateNode = this->requestedStateNodes_.front();
+            assert(this->loadedTopStateNode_);
+            if (!this->loadedTopStateNode_->parent_.expired() && requestedStateNode == this->loadedTopStateNode_->parent_.lock())
+                this->unloadState(loadedTopStateNode_->name_);
+            else // has to be child
+            {
                 try
+                {
+                    // Add tick time for most of the states
+                    uint64_t timeBeforeTick;
+                    if (!(*it)->ignoreTickTime())
+                        timeBeforeTick = this->gameClock_->getRealMicroseconds();
+                    (*it)->update(*this->gameClock_);
+                    if (!(*it)->ignoreTickTime())
+                        this->addTickTime(static_cast<uint32_t>(this->gameClock_->getRealMicroseconds() - timeBeforeTick));
+                    this->loadState(requestedStateNode->name_);
+                }
                 catch (const std::exception& ex)
+                {
+                    threwException = true;
+                    COUT(0) << "Exception while ticking: " << ex.what() << std::endl;
+                }
+                catch (...)
+                {
+                    threwException = true;
+                }
+                if (threwException)
+                {
+                    COUT(1) << "An exception occured while ticking GameState '" << (*it)->getName() << "'. This should really never happen!" << std::endl;
+                    COUT(1) << "Unloading all GameStates depending on the one that crashed." << std::endl;
+                    if ((*it)->getParent() != NULL)
+                        this->requestState((*it)->getParent()->getName());
+                    else
+                        this->stop();
+                    COUT(1) << "Error: Loading GameState '" << requestedStateNode->name_ << "' failed: " << ex.what() << std::endl;
+                    // All scheduled operations have now been rendered inert --> flush them and issue a warning
+                    if (this->requestedStateNodes_.size() > 1)
+                        COUT(1) << "All " << this->requestedStateNodes_.size() - 1 << " scheduled transitions have been ignored." << std::endl;
+                    this->requestedStateNodes_.clear();
                     break;
+                }
+            }
+            // STATISTICS
+            if (this->periodTime_ > this->configuration_->statisticsRefreshCycle_)
+            {
+                std::list<StatisticsTickInfo>::iterator it = this->statisticsTickTimes_.begin();
+                assert(it != this->statisticsTickTimes_.end());
+                int64_t lastTime = currentTime - this->configuration_->statisticsAvgLength_;
+                if (static_cast<int64_t>(it->tickTime) < lastTime)
+            }
+            this->loadedTopStateNode_ = requestedStateNode;
+            this->requestedStateNodes_.erase(this->requestedStateNodes_.begin());
+        }
+    }
+    void Game::updateGameStates()
+    {
+        // Note: The first element is the empty root state, which doesn't need ticking
+        for (GameStateVector::const_iterator it = this->loadedStates_.begin() + 1;
+            it != this->loadedStates_.end(); ++it)
+        {
+            std::string exceptionMessage;
+            try
+            {
+                // Add tick time for most of the states
+                uint64_t timeBeforeTick;
+                if ((*it)->getInfo().bIgnoreTickTime)
+                    timeBeforeTick = this->gameClock_->getRealMicroseconds();
+                (*it)->update(*this->gameClock_);
+                if ((*it)->getInfo().bIgnoreTickTime)
+                    this->subtractTickTime(static_cast<int32_t>(this->gameClock_->getRealMicroseconds() - timeBeforeTick));
+            }
+            catch (const std::exception& ex)
+            { exceptionMessage = ex.what(); }
+            catch (...)
+            { exceptionMessage = "Unknown exception"; }
+            if (!exceptionMessage.empty())
+            {
+                COUT(1) << "An exception occurred while updating '" << (*it)->getName() << "': " << exceptionMessage << std::endl;
+                COUT(1) << "This should really never happen!" << std::endl;
+                COUT(1) << "Unloading all GameStates depending on the one that crashed." << std::endl;
+                shared_ptr<GameStateTreeNode> current = this->loadedTopStateNode_;
+                while (current->name_ != (*it)->getName() && current)
+                    current = current->parent_.lock();
+                if (current && current->parent_.lock())
+                    this->requestState(current->parent_.lock()->name_);
+                else
+                    this->stop();
+                break;
+            }
+        }
+    }
+    void Game::updateStatistics()
+    {
+        // Add the tick time of this frame (rendering time has already been subtracted)
+        uint64_t currentTime = gameClock_->getMicroseconds();
+        uint64_t currentRealTime = gameClock_->getRealMicroseconds();
+        this->statisticsTickTimes_.back().tickLength += currentRealTime - currentTime;
+        this->periodTickTime_ += currentRealTime - currentTime;
+        if (this->periodTime_ > this->configuration_->statisticsRefreshCycle_)
+        {
+            std::list<StatisticsTickInfo>::iterator it = this->statisticsTickTimes_.begin();
+            assert(it != this->statisticsTickTimes_.end());
+            int64_t lastTime = currentTime - this->configuration_->statisticsAvgLength_;
+            if (static_cast<int64_t>(it->tickTime) < lastTime)
+            {
+                do
+                {
+                    do
+                    {
+                        assert(this->periodTickTime_ >= it->tickLength);
+                        this->periodTickTime_ -= it->tickLength;
+                        ++it;
+                        assert(it != this->statisticsTickTimes_.end());
+                    } while (static_cast<int64_t>(it->tickTime) < lastTime);
+                    this->statisticsTickTimes_.erase(this->statisticsTickTimes_.begin(), it);
+                }
+                uint32_t framesPerPeriod = this->statisticsTickTimes_.size();
+                this->avgFPS_ = static_cast<float>(framesPerPeriod) / (currentTime - this->statisticsTickTimes_.front().tickTime) * 1000000.0f;
+                this->avgTickTime_ = static_cast<float>(this->periodTickTime_) / framesPerPeriod / 1000.0f;
+                this->periodTime_ -= this->configuration_->statisticsRefreshCycle_;
+            }
+        }
+        // UNLOAD all remaining states
+        while (this->activeStates_.size() > 1)
+            this->unloadState(this->activeStates_.back());
+        this->activeStateNode_ = this->rootStateNode_;
+        this->requestedStateNodes_.clear();
+                    assert(this->periodTickTime_ >= it->tickLength);
+                    this->periodTickTime_ -= it->tickLength;
+                    ++it;
+                    assert(it != this->statisticsTickTimes_.end());
+                } while (static_cast<int64_t>(it->tickTime) < lastTime);
+                this->statisticsTickTimes_.erase(this->statisticsTickTimes_.begin(), it);
+            }
+            uint32_t framesPerPeriod = this->statisticsTickTimes_.size();
+            this->avgFPS_ = static_cast<float>(framesPerPeriod) / (currentTime - this->statisticsTickTimes_.front().tickTime) * 1000000.0f;
+            this->avgTickTime_ = static_cast<float>(this->periodTickTime_) / framesPerPeriod / 1000.0f;
+            this->periodTime_ -= this->configuration_->statisticsRefreshCycle_;
+        }
+    }
+    void Game::updateFPSLimiter()
+    {
+        // Why configuration_->fpsLimit_ - 1? No idea, but otherwise the fps rate is always (from 10 to 200!) one frame too high
+        uint32_t nextTime = gameClock_->getMicroseconds() - excessSleepTime_ + static_cast<uint32_t>(1000000.0f / (configuration_->fpsLimit_ - 1));
+        uint64_t currentRealTime = gameClock_->getRealMicroseconds();
+        while (currentRealTime < nextTime - minimumSleepTime_)
+        {
+            usleep(nextTime - currentRealTime);
+            currentRealTime = gameClock_->getRealMicroseconds();
+        }
+        // Integrate excess to avoid steady state error
+        excessSleepTime_ = currentRealTime - nextTime;
+        // Anti windup
+        if (excessSleepTime_ > 50000) // 20ms is about the maximum time Windows would sleep for too long
+            excessSleepTime_ = 50000;
+    }
 …
+    }
     void Game::addTickTime(uint32_t length)
+    void Game::subtractTickTime(int32_t length)
+    {
         assert(!this->statisticsTickTimes_.empty());
         this->statisticsTickTimes_.back().tickLength += length;
         this->periodTickTime_+=length;
+        this->statisticsTickTimes_.back().tickLength -= length;
+        this->periodTickTime_ -= length;
+    }
 …
     void Game::requestState(const std::string& name)
+    {
+        GameState* state = this->getState(name);
+        if (state == NULL)
+        if (!this->checkState(name))
+        {
+            COUT(2) << "Warning: GameState named '" << name << "' doesn't exist!" << std::endl;
             return;
+        //if (this->bChangingState_)
+        //{
+        //    COUT(2) << "Warning: Requesting GameStates while loading/unloading a GameState is illegal! Ignoring." << std::endl;
+        //    return;
+        //}
+        }
+        if (this->bChangingState_)
+        {
+            COUT(2) << "Warning: Requesting GameStates while loading/unloading a GameState is illegal! Ignoring." << std::endl;
+            return;
+        }
         shared_ptr<GameStateTreeNode> lastRequestedNode;
         if (this->requestedStateNodes_.empty())
             lastRequestedNode = this->activeStateNode_;
+            lastRequestedNode = this->loadedTopStateNode_;
         else
             lastRequestedNode = this->requestedStateNodes_.back();
         if (state == lastRequestedNode->state_)
+        if (name == lastRequestedNode->name_)
+        {
             COUT(2) << "Warning: Requesting the currently active state! Ignoring." << std::endl;
 …
         for (unsigned int i = 0; i < lastRequestedNode->children_.size(); ++i)
+        {
             if (lastRequestedNode->children_[i]->state_ == state)
+            if (lastRequestedNode->children_[i]->name_ == name)
+            {
                 requestedNodes.push_back(lastRequestedNode->children_[i]);
 …
             while (currentNode != NULL)
+            {
                 if (currentNode->state_ == state)
+                if (currentNode->name_ == name)
                     break;
                 currentNode = currentNode->parent_.lock();
 …
         shared_ptr<GameStateTreeNode> lastRequestedNode;
         if (this->requestedStateNodes_.empty())
             lastRequestedNode = this->activeStateNode_;
+            lastRequestedNode = this->loadedTopStateNode_;
         else
             lastRequestedNode = this->requestedStateNodes_.back();
         if (lastRequestedNode != this->rootStateNode_)
             this->requestState(lastRequestedNode->parent_.lock()->state_->getName());
+            this->requestState(lastRequestedNode->parent_.lock()->name_);
         else
             COUT(2) << "Warning: Can't pop the internal dummy root GameState" << std::endl;
+    }
     GameState* Game::getState(const std::string& name)
+    {
         std::map<std::string, GameState*>::const_iterator it = gameStates_.find(getLowercase(name));
         if (it != gameStates_.end())
+    shared_ptr<GameState> Game::getState(const std::string& name)
+    {
+        GameStateMap::const_iterator it = constructedStates_.find(name);
+        if (it != constructedStates_.end())
             return it->second;
         else
+        {
+            COUT(1) << "Error: Could not find GameState '" << name << "'. Ignoring." << std::endl;
+            return 0;
+            std::map<std::string, GameStateInfo>::const_iterator it = gameStateDeclarations_s.find(name);
+            if (it != gameStateDeclarations_s.end())
+                COUT(1) << "Error: GameState '" << name << "' has not yet been loaded." << std::endl;
+            else
+                COUT(1) << "Error: Could not find GameState '" << name << "'." << std::endl;
+            return shared_ptr<GameState>();
+        }
+    }
 …
             std::string newStateName = it->first;
             unsigned newLevel = it->second + 1; // empty root is 0
+            GameState* newState = this->getState(newStateName);
+            if (!newState)
+            if (!this->checkState(newStateName))
                 ThrowException(GameState, "GameState with name '" << newStateName << "' not found!");
             if (newState == this->rootStateNode_->state_)
+            if (newStateName == this->rootStateNode_->name_)
                 ThrowException(GameState, "You shouldn't use 'emptyRootGameState' in the hierarchy...");
             shared_ptr<GameStateTreeNode> newNode(new GameStateTreeNode);
             newNode->state_ = newState;
+            newNode->name_ = newStateName;
             if (newLevel <= currentLevel)
 …
                 newNode->parent_ = currentNode;
                 currentNode->children_.push_back(newNode);
-                currentNode->state_->addChild(newNode->state_);
+            }
             else
 …
     /*** Internal ***/
+    void Game::loadState(GameState* state)
+    void Game::loadGraphics()
+    {
+        if (!GameMode::bShowsGraphics_s)
+        {
+            core_->loadGraphics();
+            Loki::ScopeGuard graphicsUnloader = Loki::MakeObjGuard(*this, &Game::unloadGraphics);
+            GameMode::bShowsGraphics_s = true;
+            // Construct all the GameStates that require graphics
+            for (std::map<std::string, GameStateInfo>::const_iterator it = gameStateDeclarations_s.begin();
+                it != gameStateDeclarations_s.end(); ++it)
+            {
+                if (it->second.bGraphicsMode)
+                {
+                    // Game state loading failure is serious --> don't catch
+                    shared_ptr<GameState> gameState = GameStateFactory::fabricate(it->second);
+                    if (!constructedStates_.insert(std::make_pair(
+                        it->second.stateName, gameState)).second)
+                        assert(false); // GameState was already created!
+                }
+            }
+            graphicsUnloader.Dismiss();
+        }
+    }
+    void Game::unloadGraphics()
+    {
+        if (GameMode::bShowsGraphics_s)
+        {
+            // Destroy all the GameStates that require graphics
+            for (GameStateMap::iterator it = constructedStates_.begin(); it != constructedStates_.end();)
+            {
+                if (it->second->getInfo().bGraphicsMode)
+                    constructedStates_.erase(it++);
+                else
+                    ++it;
+            }
+            core_->unloadGraphics();
+            GameMode::bShowsGraphics_s = false;
+        }
+    }
+    bool Game::checkState(const std::string& name) const
+    {
+        std::map<std::string, GameStateInfo>::const_iterator it = gameStateDeclarations_s.find(name);
+        if (it == gameStateDeclarations_s.end())
+            return false;
+        else
+            return true;
+    }
+    void Game::loadState(const std::string& name)
+    {
         this->bChangingState_ = true;
+        LOKI_ON_BLOCK_EXIT_OBJ(*this, &Game::resetChangingState);
+        // If state requires graphics, load it
+        Loki::ScopeGuard graphicsUnloader = Loki::MakeObjGuard(*this, &Game::unloadGraphics);
+        if (gameStateDeclarations_s[name].bGraphicsMode && !GameMode::showsGraphics())
+            this->loadGraphics();
+        else
+            graphicsUnloader.Dismiss();
+        shared_ptr<GameState> state = this->getState(name);
         state->activate();
         if (!this->activeStates_.empty())
             this->activeStates_.back()->activity_.topState = false;
         this->activeStates_.push_back(state);
+        if (!this->loadedStates_.empty())
+            this->loadedStates_.back()->activity_.topState = false;
+        this->loadedStates_.push_back(state);
         state->activity_.topState = true;
+        graphicsUnloader.Dismiss();
+    }
+    void Game::unloadState(const std::string& name)
+    {
+        this->bChangingState_ = true;
+        try
+        {
+            shared_ptr<GameState> state = this->getState(name);
+            state->activity_.topState = false;
+            this->loadedStates_.pop_back();
+            if (!this->loadedStates_.empty())
+                this->loadedStates_.back()->activity_.topState = true;
+            state->deactivate();
+        }
+        catch (const std::exception& ex)
+        {
+            COUT(2) << "Warning: Unloading GameState '" << name << "' threw an exception: " << ex.what() << std::endl;
+            COUT(2) << "         There might be potential resource leaks involved! To avoid this, improve exception-safety." << std::endl;
+        }
+        // Check if graphics is still required
+        bool graphicsRequired = false;
+        for (unsigned i = 0; i < loadedStates_.size(); ++i)
+            graphicsRequired |= loadedStates_[i]->getInfo().bGraphicsMode;
+        if (!graphicsRequired)
+            this->unloadGraphics();
         this->bChangingState_ = false;
+    }
+    void Game::unloadState(orxonox::GameState* state)
+    {
+        this->bChangingState_ = true;
+        state->activity_.topState = false;
+        this->activeStates_.pop_back();
+        if (!this->activeStates_.empty())
+            this->activeStates_.back()->activity_.topState = true;
+        try
+        {
+            state->deactivate();
+        }
+        catch (const std::exception& ex)
+        {
+            COUT(2) << "Warning: Unloading GameState '" << state->getName() << "' threw an exception: " << ex.what() << std::endl;
+            COUT(2) << "         There might be potential resource leaks involved! To avoid this, improve exception-safety." << std::endl;
+        }
+        this->bChangingState_ = false;
+    }
+    std::map<std::string, Game::GameStateFactory*> Game::GameStateFactory::factories_s;
+    /*static*/ GameState* Game::GameStateFactory::fabricate(const std::string& className, const GameStateConstrParams& params)
+    {
+        std::map<std::string, GameStateFactory*>::const_iterator it = factories_s.find(className);
+    std::map<std::string, shared_ptr<Game::GameStateFactory> > Game::GameStateFactory::factories_s;
+    /*static*/ shared_ptr<GameState> Game::GameStateFactory::fabricate(const GameStateInfo& info)
+    {
+        std::map<std::string, shared_ptr<Game::GameStateFactory> >::const_iterator it = factories_s.find(info.className);
         assert(it != factories_s.end());
+        return it->second->fabricate(params);
+    }
+    /*static*/ void Game::GameStateFactory::destroyFactories()
+    {
+        for (std::map<std::string, GameStateFactory*>::const_iterator it = factories_s.begin(); it != factories_s.end(); ++it)
+            delete it->second;
+        factories_s.clear();
+        return it->second->fabricateInternal(info);
+    }
+}

code/trunk/src/core/Game.h

-                      r3323
+                      r3370
 #include <vector>
 #include <boost/shared_ptr.hpp>
+#include <boost/scoped_ptr.hpp>
 #include <boost/preprocessor/cat.hpp>
 #include "util/Debug.h"
 #include "util/StringUtils.h"
+#include "util/Singleton.h"
 /**
 …
+{
     class GameConfiguration;
+    using boost::scoped_ptr;
+    using boost::shared_ptr;
+    //! Helper object required before GameStates are being constructed
+    struct GameStateInfo
+    {
+        std::string stateName;
+        std::string className;
+        bool bIgnoreTickTime;
+        bool bGraphicsMode;
+    };
     /**
     @brief
         Main class responsible for running the game.
+    @remark
+        You should only create this singleton once because it owns the Core class! (see remark there)
     */
     class _CoreExport Game
+    class _CoreExport Game : public Singleton<Game>
+    {
+        friend class Singleton<Game>;
+        typedef std::vector<shared_ptr<GameState> > GameStateVector;
+        typedef std::map<std::string, shared_ptr<GameState> > GameStateMap;
+        typedef boost::shared_ptr<GameStateTreeNode> GameStateTreeNodePtr;
     public:
         Game(const std::string& cmdLine);
 …
         void setStateHierarchy(const std::string& str);
         GameState* getState(const std::string& name);
+        shared_ptr<GameState> getState(const std::string& name);
         void run();
 …
         float getAvgFPS()      { return this->avgFPS_; }
         void addTickTime(uint32_t length);
+        void subtractTickTime(int32_t length);
         template <class T>
         static bool declareGameState(const std::string& className, const std::string& stateName, bool bIgnoreTickTime, bool bConsoleMode);
-        static Game& getInstance() { assert(singletonRef_s); return *singletonRef_s; }
     private:
 …
         public:
             virtual ~GameStateFactory() { }
             static GameState* fabricate(const std::string& className, const GameStateConstrParams& params);
+            static shared_ptr<GameState> fabricate(const GameStateInfo& info);
             template <class T>
             static void createFactory(const std::string& className)
+                { factories_s[className] = new TemplateGameStateFactory<T>(); }
+            static void destroyFactories();
+                { factories_s[className].reset(new TemplateGameStateFactory<T>()); }
         private:
             virtual GameState* fabricate(const GameStateConstrParams& params) = 0;
             static std::map<std::string, GameStateFactory*> factories_s;
+            virtual shared_ptr<GameState> fabricateInternal(const GameStateInfo& info) = 0;
+            static std::map<std::string, shared_ptr<GameStateFactory> > factories_s;
         };
         template <class T>
 …
+        {
         public:
+            GameState* fabricate(const GameStateConstrParams& params)
+                { return new T(params); }
+        };
+        struct GameStateInfo
+        {
+            std::string stateName;
+            std::string className;
+            bool bIgnoreTickTime;
+            bool bGraphicsMode;
+            shared_ptr<GameState> fabricateInternal(const GameStateInfo& info)
+                { return shared_ptr<GameState>(new T(info)); }
         };
 …
         Game(Game&); // don't mess with singletons
+        void loadState(GameState* state);
+        void unloadState(GameState* state);
+        std::map<std::string, GameState*>    gameStates_;
+        std::vector<GameState*>              activeStates_;
+        boost::shared_ptr<GameStateTreeNode> rootStateNode_;
+        boost::shared_ptr<GameStateTreeNode> activeStateNode_;
+        std::vector<boost::shared_ptr<GameStateTreeNode> > requestedStateNodes_;
+        Core*                           core_;
+        Clock*                          gameClock_;
+        GameConfiguration*              configuration_;
+        bool                            bChangingState_;
+        bool                            bAbort_;
+        void loadGraphics();
+        void unloadGraphics();
+        bool checkState(const std::string& name) const;
+        void loadState(const std::string& name);
+        void unloadState(const std::string& name);
+        // Main loop structuring
+        void updateGameStateStack();
+        void updateGameStates();
+        void updateStatistics();
+        void updateFPSLimiter();
+        // ScopeGuard helper function
+        void resetChangingState() { this->bChangingState_ = false; }
+        scoped_ptr<Clock>                  gameClock_;
+        scoped_ptr<Core>                   core_;
+        scoped_ptr<GameConfiguration>      configuration_;
+        GameStateMap                       constructedStates_;
+        GameStateVector                    loadedStates_;
+        GameStateTreeNodePtr               rootStateNode_;
+        GameStateTreeNodePtr               loadedTopStateNode_;
+        std::vector<GameStateTreeNodePtr>  requestedStateNodes_;
+        bool                               bChangingState_;
+        bool                               bAbort_;
         // variables for time statistics
+        uint64_t                        statisticsStartTime_;
+        std::list<StatisticsTickInfo>   statisticsTickTimes_;
+        uint32_t                        periodTime_;
+        uint32_t                        periodTickTime_;
+        float                           avgFPS_;
+        float                           avgTickTime_;
+        uint64_t                           statisticsStartTime_;
+        std::list<StatisticsTickInfo>      statisticsTickTimes_;
+        uint32_t                           periodTime_;
+        uint32_t                           periodTickTime_;
+        float                              avgFPS_;
+        float                              avgTickTime_;
+        int                                excessSleepTime_;
+        unsigned int                       minimumSleepTime_;
         static std::map<std::string, GameStateInfo> gameStateDeclarations_s;
         static Game* singletonRef_s;        //!< Pointer to the Singleton
+        static Game* singletonPtr_s;        //!< Pointer to the Singleton
     };
 …
     /*static*/ bool Game::declareGameState(const std::string& className, const std::string& stateName, bool bIgnoreTickTime, bool bGraphicsMode)
+    {
         std::map<std::string, GameStateInfo>::const_iterator it = gameStateDeclarations_s.find(getLowercase(stateName));
+        std::map<std::string, GameStateInfo>::const_iterator it = gameStateDeclarations_s.find(stateName);
         if (it == gameStateDeclarations_s.end())
+        {
             GameStateInfo& info = gameStateDeclarations_s[getLowercase(stateName)];
+            GameStateInfo& info = gameStateDeclarations_s[stateName];
             info.stateName = stateName;
             info.className = className;

code/trunk/src/core/GameMode.h

-                      r2896
+                      r3370
     class _CoreExport GameMode
+    {
+        friend class Game;
         public:
             static bool showsGraphics() { return bShowsGraphics_s; }
 …
             static bool isStandalone()  { return bIsStandalone_s; }
             static bool isMaster()      { return bIsMaster_s; }
+            static void setShowsGraphics(bool val) { bShowsGraphics_s = val; updateIsMaster(); }
             static void setHasServer    (bool val) { bHasServer_s     = val; updateIsMaster(); }
             static void setIsClient     (bool val) { bIsClient_s      = val; updateIsMaster(); }
             static void setIsStandalone (bool val) { bIsStandalone_s  = val; updateIsMaster(); }
-            static void updateIsMaster  ()         { bIsMaster_s      = (bHasServer_s || bIsStandalone_s); }
         private:
 …
             GameMode(const GameMode& inst);
             ~GameMode();
+            static void updateIsMaster()
+            {
+                bIsMaster_s = (bHasServer_s || bIsStandalone_s);
+            }
             static bool bShowsGraphics_s;                   //!< global variable that tells whether to show graphics

code/trunk/src/core/GameState.cc

-                      r3280
+                      r3370
 #include "util/Exception.h"
 #include "util/OrxAssert.h"
+#include "Game.h"
 namespace orxonox
 …
         Constructor only initialises variables and sets the name permanently.
     */
+    GameState::GameState(const GameStateConstrParams& params)
+        : name_(params.name)
+        , bIgnoreTickTime_(params.bIgnoreTickTime)
+        , parent_(0)
+    GameState::GameState(const GameStateInfo& info)
+        : info_(info)
+    {
         this->activity_.activating   = false;
 …
+    }
+    /**
+    @brief
+        Adds a child to the current tree. The Child can contain children of its own.
+        But you cannot a state tree that already has an active state.
+    @param state
+        The state to be added.
+    */
+    void GameState::addChild(GameState* state)
+    const std::string& GameState::getName() const
+    {
+        assert(state != NULL);
+        std::map<std::string, GameState*>::const_iterator it = this->children_.find(state->getName());
+        if (it == this->children_.end())
+        {
+            this->children_[state->getName()] = state;
+            // mark us as parent
+            state->setParent(this);
+        }
+        else
+        {
+            ThrowException(GameState, "Cannot add two children with the same name");
+        }
+    }
+    /**
+    @brief
+        Removes a child by instance. This splits the tree in two parts,
+        each of them functional on its own.
+    @param state
+        GameState by instance pointer
+    */
+    void GameState::removeChild(GameState* state)
+    {
+        assert(state != NULL);
+        std::map<std::string, GameState*>::iterator it = this->children_.find(state->getName());
+        if (it != this->children_.end())
+            this->children_.erase(it);
+        else
+        {
+            ThrowException(GameState, "Game state '" + name_ + "' doesn't have a child named '"
+                + state->getName() + "'.");
+        }
+        return info_.stateName;
+    }

code/trunk/src/core/GameState.h

-                      r3280
+                      r3370
     /**
     @brief
-        Helper class to group construction parameters for better genericity.
-    */
-    struct GameStateConstrParams
+    {
-        std::string name;
-        bool bIgnoreTickTime;
-    };
-    /**
-    @brief
         An implementation of a tree to manage game states.
         This leads to a certain hierarchy that is created at runtime.
 …
     public:
         GameState(const GameStateConstrParams& params);
+        GameState(const GameStateInfo& info);
         virtual ~GameState();
+        const std::string& getName() const { return name_; }
+        State getActivity()          const { return this->activity_; }
+        GameState* getParent()       const { return this->parent_; }
+        bool ignoreTickTime()        const { return this->bIgnoreTickTime_; }
+        void addChild(GameState* state);
+        void removeChild(GameState* state);
+        const std::string& getName()   const;
+        State getActivity()            const { return activity_; }
+        const GameStateInfo& getInfo() const { return info_; }
     protected:
 …
     private:
-        void setParent(GameState* state) { this->parent_ = state; }
         void setActivity(State activity);
         void activateInternal();
 …
         void updateInternal(const Clock& time);
+        const std::string                        name_;
+        State                                    activity_;
+        const bool                               bIgnoreTickTime_;
+        GameState*                               parent_;
+        std::map<std::string, GameState*>        children_;
+        const GameStateInfo& info_;
+        State                activity_;
     };
+}

code/trunk/src/core/IRC.cc

-                      r3318
+                      r3370
         try
+        {
             this->interpreter_->def("orxonox::irc::say", IRC::tcl_say, Tcl::variadic());
             this->interpreter_->def("orxonox::irc::privmsg", IRC::tcl_privmsg, Tcl::variadic());
             this->interpreter_->def("orxonox::irc::action", IRC::tcl_action, Tcl::variadic());
             this->interpreter_->def("orxonox::irc::info", IRC::tcl_info, Tcl::variadic());
+            this->interpreter_->def("::orxonox::irc::say", IRC::tcl_say, Tcl::variadic());
+            this->interpreter_->def("::orxonox::irc::privmsg", IRC::tcl_privmsg, Tcl::variadic());
+            this->interpreter_->def("::orxonox::irc::action", IRC::tcl_action, Tcl::variadic());
+            this->interpreter_->def("::orxonox::irc::info", IRC::tcl_info, Tcl::variadic());
+        }
         catch (Tcl::tcl_error const &e)

code/trunk/src/core/Identifier.h

-                      r3333
+                      r3370
 #ifdef ORXONOX_COMPILER_MSVC
         typedef Loki::TypeTraits<typename Loki::TypeTraits<T>::PointeeType>::NonConstType ClassType;
+        return source->template getDerivedPointer<ClassType>(ClassIdentifier<ClassType>::getIdentifier()->getClassID());
+        if (source != NULL)
+            return source->template getDerivedPointer<ClassType>(ClassIdentifier<ClassType>::getIdentifier()->getClassID());
+        else
+            return NULL;
 #else
         return dynamic_cast<T>(source);

code/trunk/src/core/Language.cc

-                      r3280
+                      r3370
     // ###############################
     Language* Language::singletonRef_s = 0;
+    Language* Language::singletonPtr_s = 0;
     /**
 …
     Language::Language()
+    {
-        assert(singletonRef_s == 0);
-        singletonRef_s = this;
         this->defaultLanguage_ = "default";
         this->defaultLocalisation_ = "ERROR: LANGUAGE ENTRY DOESN'T EXIST!";
 …
         for (std::map<std::string, LanguageEntry*>::iterator it = this->languageEntries_.begin(); it != this->languageEntries_.end(); ++it)
             delete (it->second);
-        assert(singletonRef_s);
-        singletonRef_s = 0;
+    }

code/trunk/src/core/Language.h

-                      r3280
+                      r3370
     Usage:
      - Set the entry with the default string:
        Language::getLanguage()->addEntry("label of the entry", "the string to translate");
+       Language::getInstance()->addEntry("label of the entry", "the string to translate");
      - Get the localisation of the entry in the configured language:
        std::cout << Language::getLanguage()->getLocalisation("name of the entry") << std::endl;
+       std::cout << Language::getInstance()->getLocalisation("name of the entry") << std::endl;
 */
 …
 #include <string>
 #include <cassert>
+#include "util/Singleton.h"
 #define AddLanguageEntry(label, fallbackstring) \
     orxonox::Language::getLanguage().addEntry(label, fallbackstring)
+    orxonox::Language::getInstance().addEntry(label, fallbackstring)
 #define GetLocalisation(label) \
     orxonox::Language::getLanguage().getLocalisation(label)
+    orxonox::Language::getInstance().getLocalisation(label)
 …
     // ###############################
     //! The Language class manges the language files and entries and stores the LanguageEntry objects in a map.
     class _CoreExport Language
+    class _CoreExport Language : public Singleton<Language>
+    {
+        friend class Singleton<Language>;
         friend class CoreConfiguration;
 …
             ~Language();
-            static Language& getLanguage() { assert(singletonRef_s); return *singletonRef_s; }
             void addEntry(const LanguageEntryLabel& label, const std::string& entry);
             const std::string& getLocalisation(const LanguageEntryLabel& label) const;
 …
             std::map<std::string, LanguageEntry*> languageEntries_; //!< A map to store all LanguageEntry objects and their labels
             static Language* singletonRef_s;
+            static Language* singletonPtr_s;
     };
+}

code/trunk/src/core/Loader.cc

-                      r3196
+                      r3370
 #include <tinyxml/ticpp.h>
-#include <boost/filesystem.hpp>
 #include "util/Debug.h"
 #include "util/Exception.h"
 #include "BaseObject.h"
-#include "Core.h"
 #include "Iterator.h"
 #include "ObjectList.h"
 …
         return Loader::load(file, mask);
+    }
-    std::vector<std::string> Loader::getLevelList()
+    {
-        std::vector<std::string> levelList;
-        boost::filesystem::directory_iterator file(Core::getMediaPathString() + "levels");
-        boost::filesystem::directory_iterator end;
-        while (file != end)
+        {
-            if (!boost::filesystem::is_directory(*file) && file->string()[file->string().length()-1] != '~')
+            {
-                std::string filename = file->path().leaf();
-                if (filename.length() > 4)
-                    levelList.push_back(filename.substr(0,filename.length()-4));
+            }
-            ++file;
+        }
-        return levelList;
+    }
+}

code/trunk/src/core/Loader.h

r3196	r3370
56	56
57	57	static ClassTreeMask currentMask_s;
58		~~static std::vector<std::string> getLevelList();~~
59	58
60	59	private:

code/trunk/src/core/LuaBind.cc

-                      r3301
+                      r3370
 #include "util/Debug.h"
 #include "util/StringUtils.h"
-#include "ToluaBindCore.h"
 #include "Core.h"
 namespace orxonox
+{
   LuaBind* LuaBind::singletonRef_s = NULL;
+  LuaBind* LuaBind::singletonPtr_s = NULL;
   LuaBind::LuaBind()
+  {
-    assert(LuaBind::singletonRef_s == 0);
-    LuaBind::singletonRef_s = this;
     this->includePath_ = Core::getMediaPathString();
 …
     luaopen_debug(luaState_);
 #endif
+    tolua_Core_open(luaState_);
+    // Open all available tolua interfaces
+    this->openToluaInterfaces(luaState_);
     output_ = "";
     isRunning_ = false;
+  }
+  LuaBind::~LuaBind()
+  {
+    this->closeToluaInterfaces(luaState_);
+  };
   void LuaBind::luaPrint(const std::string& str)
 …
+  }
+  void LuaBind::addToluaInterface(int (*function)(lua_State*), const std::string& name)
+  {
+    toluaInterfaces_.push_back(std::make_pair(name, function));
+    // Apply changes to our own lua state as well
+    (*function)(luaState_);
+  }
+  void LuaBind::openToluaInterfaces(lua_State* state)
+  {
+    for (unsigned int i = 0; i < toluaInterfaces_.size(); ++i)
+      (*toluaInterfaces_[i].second)(state);
+  }
+  void LuaBind::closeToluaInterfaces(lua_State* state)
+  {
+    for (unsigned int i = 0; i < toluaInterfaces_.size(); ++i)
+    {
+      lua_pushnil(state);
+      lua_setglobal(state, toluaInterfaces_[i].first.c_str());
+    }
+  }
+}

code/trunk/src/core/LuaBind.h

-                      r3196
+                      r3370
 #include <cassert>
 #include <string>
+#include <vector>
 extern "C" {
 #include <lua.h>
+}
+#include "util/Singleton.h"
 // tolua_begin
 namespace orxonox
+{
   class _CoreExport LuaBind
+  class _CoreExport LuaBind : public Singleton<LuaBind>
+  {
+// tolua_end
+    friend class Singleton<LuaBind>;
-// tolua_end
     struct LoadS {
       const char *s;
 …
     public:
       LuaBind();
       inline ~LuaBind() { assert(singletonRef_s); LuaBind::singletonRef_s = NULL; };
+      ~LuaBind();
       inline static LuaBind& getInstance() { assert(singletonRef_s); return *LuaBind::singletonRef_s; } // tolua_export
+      static LuaBind& getInstance() { return Singleton<LuaBind>::getInstance(); } // tolua_export
     void loadFile(const std::string& filename, bool luaTags);
 …
         { this->includePath_ = includepath; }
+    void addToluaInterface(int (*function)(lua_State*), const std::string& name);
+    void openToluaInterfaces(lua_State* state);
+    void closeToluaInterfaces(lua_State* state);
     private:
       static LuaBind* singletonRef_s;
+      static LuaBind* singletonPtr_s;
       std::string luaSource_;
 …
       bool isRunning_;
       std::string includePath_;
+      std::vector<std::pair<std::string, int (*)(lua_State *L)> > toluaInterfaces_;
   }; // tolua_export

code/trunk/src/core/Shell.cc

-                      r3301
+                      r3370
     SetConsoleCommandShortcut(OutputHandler, debug);
     Shell* Shell::singletonRef_s = 0;
+    Shell* Shell::singletonPtr_s = 0;
     Shell::Shell()
+    {
-        assert(singletonRef_s == 0);
-        singletonRef_s = this;
         int level = Core::getSoftDebugLevel(OutputHandler::LD_Shell);
         Core::setSoftDebugLevel(OutputHandler::LD_Shell, -1);
 …
         if (this->inputBuffer_)
             delete this->inputBuffer_;
-        singletonRef_s = 0;
+    }

code/trunk/src/core/Shell.h

-                      r3280
+                      r3370
     };
     class _CoreExport Shell : virtual public OrxonoxClass, public OutputBufferListener
+    class _CoreExport Shell : public Singleton<Shell>, virtual public OrxonoxClass, public OutputBufferListener
+    {
+        friend class Singleton<Shell>;
         public:
             Shell();
             virtual ~Shell();
-            static Shell& getInstance() { assert(singletonRef_s); return *singletonRef_s; }
             static void clearShell();
 …
             ConfigFileType commandHistoryConfigFileType_;
             static Shell* singletonRef_s;
+            static Shell* singletonPtr_s;
     };
+}

code/trunk/src/core/TclBind.cc

-                      r3318
+                      r3370
 #include <cpptcl/cpptcl.h>
+#include "SpecialConfig.h"
 #include "util/Debug.h"
 #include "util/StringUtils.h"
 #include "CommandExecutor.h"
 #include "ConsoleCommand.h"
+#include "Core.h"
 #include "TclThreadManager.h"
 …
     SetConsoleCommandShortcut(TclBind, bgerror);
     TclBind* TclBind::singletonRef_s = 0;
+    TclBind* TclBind::singletonPtr_s = 0;
     TclBind::TclBind(const std::string& datapath)
+    {
-        assert(singletonRef_s == 0);
-        singletonRef_s = this;
         this->interpreter_ = 0;
         this->bSetTclLibPath_ = false;
+        this->bSetTclDataPath_ = false;
         this->setDataPath(datapath);
+    }
 …
         if (this->interpreter_)
             delete this->interpreter_;
-        singletonRef_s = 0;
+    }
 …
+    {
         // String has POSIX slashes
+        this->tclLibPath_ = datapath + "tcl" + TCL_VERSION + '/';
+        this->bSetTclLibPath_ = true;
+        this->createTclInterpreter();
+    }
+    void TclBind::createTclInterpreter()
+    {
+        if (this->bSetTclLibPath_ && !this->interpreter_)
+        {
+            this->interpreter_ = new Tcl::interpreter(this->tclLibPath_);
+            this->interpreter_->def("orxonox::query", TclBind::tcl_query, Tcl::variadic());
+            this->interpreter_->def("orxonox::crossquery", TclThreadManager::tcl_crossquery, Tcl::variadic());
+        this->tclDataPath_ = datapath + "tcl" + '/';
+        this->bSetTclDataPath_ = true;
+        this->initializeTclInterpreter();
+    }
+    void TclBind::initializeTclInterpreter()
+    {
+        if (this->bSetTclDataPath_ && !this->interpreter_)
+        {
+            this->interpreter_ = this->createTclInterpreter();
+            this->interpreter_->def("::orxonox::query", TclBind::tcl_query, Tcl::variadic());
+            this->interpreter_->def("::orxonox::crossquery", TclThreadManager::tcl_crossquery, Tcl::variadic());
             this->interpreter_->def("execute", TclBind::tcl_execute, Tcl::variadic());
             this->interpreter_->def("orxonox::crossexecute", TclThreadManager::tcl_crossexecute, Tcl::variadic());
+            this->interpreter_->def("::orxonox::crossexecute", TclThreadManager::tcl_crossexecute, Tcl::variadic());
             try
+            {
+                this->interpreter_->eval("proc query args { orxonox::query [join $args] }");
+                this->interpreter_->eval("proc crossquery {id args} { orxonox::crossquery 0 $id [join $args] }");
+                this->interpreter_->eval("proc crossexecute {id args} { orxonox::crossquery 0 $id [join $args] }");
+                this->interpreter_->eval("proc query        {args}    { ::orxonox::query $args }");
+                this->interpreter_->eval("proc crossquery   {id args} { ::orxonox::crossquery 0 $id $args }");
+                this->interpreter_->eval("proc crossexecute {id args} { ::orxonox::crossquery 0 $id $args }");
+                this->interpreter_->eval("proc running      {}        { return 1 }");
                 this->interpreter_->eval("set id 0");
+                this->interpreter_->eval("rename exit tcl::exit; proc exit {} { execute exit }");
+                this->interpreter_->eval("redef_puts");
+                this->interpreter_->eval("rename exit ::tcl::exit; proc exit {} { execute exit }");
+            }
             catch (Tcl::tcl_error const &e)
 …
             catch (std::exception const &e)
             {   COUT(1) << "Error while creating Tcl-interpreter: " << e.what() << std::endl;   }
+        }
+    }
+    void TclBind::createNewTclInterpreter()
+    {
+        if (this->interpreter_)
+        {
+            delete this->interpreter_;
+            this->interpreter_ = 0;
+        }
+        this->createTclInterpreter();
+            catch (...)
+            {   COUT(1) << "Error while creating Tcl-interpreter." << std::endl;   }
+        }
+    }
+    Tcl::interpreter* TclBind::createTclInterpreter()
+    {
+        Tcl::interpreter* interpreter = new Tcl::interpreter();
+        std::string libpath = TclBind::getTclLibraryPath();
+        try
+        {
+            if (libpath != "")
+                interpreter->eval("set tcl_library \"" + libpath + "\"");
+            Tcl_Init(interpreter->get());
+            interpreter->eval("source \"" + TclBind::getInstance().tclDataPath_ + "/init.tcl\"");
+        }
+        catch (Tcl::tcl_error const &e)
+        {   COUT(1) << "Tcl error while creating Tcl-interpreter: " << e.what() << std::endl; COUT(1) << "Error: Tcl isn't properly initialized. Orxonox might possibly not work like that." << std::endl;   }
+        catch (std::exception const &e)
+        {   COUT(1) << "Error while creating Tcl-interpreter: " << e.what() << std::endl; COUT(1) << "Error: Tcl isn't properly initialized. Orxonox might possibly not work like that." << std::endl;   }
+        catch (...)
+        {   COUT(1) << "Error while creating Tcl-interpreter." << std::endl; COUT(1) << "Error: Tcl isn't properly initialized. Orxonox might possibly not work like that." << std::endl;   }
+        return interpreter;
+    }
+    std::string TclBind::getTclLibraryPath()
+    {
+#ifdef DEPENDENCY_PACKAGE_ENABLE
+        if (Core::isDevelopmentRun())
+            return (std::string(ORXONOX_DEP_LIB_PATH) + "/tcl");
+        else
+            return (Core::getRootPathString() + "lib/tcl");
+#else
+        return "";
+#endif
+    }
 …
             try
+            {
                 std::string output = TclBind::getInstance().interpreter_->eval(tclcode);
+                std::string output = TclBind::getInstance().interpreter_->eval("uplevel #0 " + tclcode);
                 if (output != "")
+                {

code/trunk/src/core/TclBind.h

-                      r3196
+                      r3370
 #include <cassert>
 #include <string>
+#include "util/Singleton.h"
 namespace orxonox
+{
     class _CoreExport TclBind
+    class _CoreExport TclBind : public Singleton<TclBind>
+    {
+        friend class Singleton<TclBind>;
         public:
             TclBind(const std::string& datapath);
             ~TclBind();
-            static TclBind& getInstance() { assert(singletonRef_s); return *singletonRef_s; }
             static std::string tcl(const std::string& tclcode);
 …
             void setDataPath(const std::string& datapath);
+            std::string getTclLibPath() const { return this->tclLibPath_; }
+            void createTclInterpreter();
+            void createNewTclInterpreter();
+            const std::string& getTclDataPath() const { return this->tclDataPath_; }
+            static std::string getTclLibraryPath();
+            void initializeTclInterpreter();
+            static Tcl::interpreter* createTclInterpreter();
             Tcl::interpreter* getTclInterpreter() const { return this->interpreter_; }
 …
             Tcl::interpreter* interpreter_;
             std::string tclLibPath_;
             bool bSetTclLibPath_;
+            std::string tclDataPath_;
+            bool bSetTclDataPath_;
             static TclBind* singletonRef_s;
+            static TclBind* singletonPtr_s;
     };
+}

code/trunk/src/core/TclThreadManager.cc

-                      r3326
+                      r3370
     SetConsoleCommand(TclThreadManager, execute, false).argumentCompleter(0, autocompletion::tclthreads());
     SetConsoleCommand(TclThreadManager, query,   false).argumentCompleter(0, autocompletion::tclthreads());
+    SetConsoleCommand(TclThreadManager, source,  false).argumentCompleter(0, autocompletion::tclthreads());
     /**
 …
         RegisterRootObject(TclThreadManager);
-        assert(TclThreadManager::singletonPtr_s == 0);
-        TclThreadManager::singletonPtr_s = this;
         this->numInterpreterBundles_ = 0;
 …
     TclThreadManager::~TclThreadManager()
+    {
-        TclThreadManager::singletonPtr_s = 0;
         delete this->interpreterBundlesMutex_;
 //        delete this->mainInterpreterMutex_; // <-- temporary disabled to avoid crash if a thread is still actively queriyng
 …
         TclInterpreterBundle* newbundle = new TclInterpreterBundle();
         newbundle->id_ = id;
+        newbundle->interpreter_ = new Tcl::interpreter(TclBind::getInstance().getTclLibPath());
+        // Initialize the new interpreter
+        try
+        {
+            std::string id_string = getConvertedValue<unsigned int, std::string>(id);
+            // Define the functions which are implemented in C++
+            newbundle->interpreter_->def("orxonox::execute",      TclThreadManager::tcl_execute,      Tcl::variadic());
+            newbundle->interpreter_->def("orxonox::crossexecute", TclThreadManager::tcl_crossexecute, Tcl::variadic());
+            newbundle->interpreter_->def("orxonox::query",        TclThreadManager::tcl_query,        Tcl::variadic());
+            newbundle->interpreter_->def("orxonox::crossquery",   TclThreadManager::tcl_crossquery,   Tcl::variadic());
+            newbundle->interpreter_->def("orxonox::running",      TclThreadManager::tcl_running);
+            // Create threadspecific shortcuts for the functions above
+            newbundle->interpreter_->def("execute",      TclThreadManager::tcl_execute,      Tcl::variadic());
+            newbundle->interpreter_->def("crossexecute", TclThreadManager::tcl_crossexecute, Tcl::variadic());
+            newbundle->interpreter_->eval("proc query       args     { orxonox::query " + id_string + " $args }");
+            newbundle->interpreter_->eval("proc crossquery {id args} { orxonox::crossquery " + id_string + " $id $args }");
+            // Define a variable containing the thread id
+            newbundle->interpreter_->eval("set id " + id_string);
+            // Use our own exit function to avoid shutting down the whole program instead of just the interpreter
+            newbundle->interpreter_->eval("rename exit tcl::exit");
+            newbundle->interpreter_->eval("proc exit {} { execute TclThreadManager destroy " + id_string + " }");
+            // Redefine some native functions
+            newbundle->interpreter_->eval("redef_puts");
+//            newbundle->interpreter_->eval("rename while tcl::while");
+//            newbundle->interpreter_->eval("proc while {test command} { tcl::while {[uplevel 1 expr $test]} {uplevel 1 $command} }"); // (\"$test\" && [orxonox::running " + id + "]])
+//            newbundle->interpreter_->eval("rename for tcl::for");
+//            newbundle->interpreter_->eval("proc for {start test next command} { uplevel tcl::for \"$start\" \"$test\" \"$next\" \"$command\" }");
+        }
+        catch (const Tcl::tcl_error& e)
+        {   newbundle->interpreter_ = 0; COUT(1) << "Tcl error while creating Tcl-interpreter (" << id << "): " << e.what() << std::endl;   }
+        catch (const std::exception& e)
+        {   newbundle->interpreter_ = 0; COUT(1) << "Error while creating Tcl-interpreter (" << id << "): " << e.what() << std::endl;   }
+        catch (...)
+        {   newbundle->interpreter_ = 0; COUT(1) << "An error occurred while creating a new Tcl-interpreter (" << id << ")" << std::endl;   }
+        newbundle->interpreter_ = TclBind::createTclInterpreter();
+        TclThreadManager::initialize(newbundle);
+        {
 …
+    }
+    void TclThreadManager::initialize(TclInterpreterBundle* bundle)
+    {
+        std::string id_string = getConvertedValue<unsigned int, std::string>(bundle->id_);
+        // Initialize the new interpreter
+        try
+        {
+            // Define the functions which are implemented in C++
+            bundle->interpreter_->def("::orxonox::execute",      TclThreadManager::tcl_execute,      Tcl::variadic());
+            bundle->interpreter_->def("::orxonox::crossexecute", TclThreadManager::tcl_crossexecute, Tcl::variadic());
+            bundle->interpreter_->def("::orxonox::query",        TclThreadManager::tcl_query,        Tcl::variadic());
+            bundle->interpreter_->def("::orxonox::crossquery",   TclThreadManager::tcl_crossquery,   Tcl::variadic());
+            bundle->interpreter_->def("::orxonox::running",      TclThreadManager::tcl_running);
+            // Create threadspecific shortcuts for the functions above
+            bundle->interpreter_->def("execute",      TclThreadManager::tcl_execute,      Tcl::variadic());
+            bundle->interpreter_->def("crossexecute", TclThreadManager::tcl_crossexecute, Tcl::variadic());
+            bundle->interpreter_->eval("proc query      {args}    { ::orxonox::query " + id_string + " $args }");
+            bundle->interpreter_->eval("proc crossquery {id args} { ::orxonox::crossquery " + id_string + " $id $args }");
+            bundle->interpreter_->eval("proc running    {}        { return [::orxonox::running " + id_string + "] }");
+            // Define a variable containing the thread id
+            bundle->interpreter_->eval("set id " + id_string);
+            // Use our own exit function to avoid shutting down the whole program instead of just the interpreter
+            bundle->interpreter_->eval("rename exit ::tcl::exit");
+            bundle->interpreter_->eval("proc exit {} { execute TclThreadManager destroy " + id_string + " }");
+            // Redefine some native functions
+            bundle->interpreter_->eval("rename while ::tcl::while");
+            bundle->interpreter_->eval("rename ::orxonox::while while");
+            bundle->interpreter_->eval("rename for ::tcl::for");
+            bundle->interpreter_->eval("rename ::orxonox::for for");
+        }
+        catch (const Tcl::tcl_error& e)
+        {   bundle->interpreter_ = 0; COUT(1) << "Tcl error while creating Tcl-interpreter (" << id_string << "): " << e.what() << std::endl;   }
+        catch (const std::exception& e)
+        {   bundle->interpreter_ = 0; COUT(1) << "Error while creating Tcl-interpreter (" << id_string << "): " << e.what() << std::endl;   }
+        catch (...)
+        {   bundle->interpreter_ = 0; COUT(1) << "An error occurred while creating a new Tcl-interpreter (" << id_string << ")" << std::endl;   }
+    }
     /**
         @brief Stops and destroys a given Tcl-interpreter
 …
         // TODO
         // Not yet implemented
+        TclInterpreterBundle* bundle = TclThreadManager::getInstance().getInterpreterBundle(id);
+        if (bundle)
+        {
+            bundle->bRunning_ = false;
+        }
+    }
 …
+            {
                 // This query would lead to a deadlock - return with an error
                 this->error("Error: Circular query (" + this->dumpList(source_bundle->queriers_.getList()) + " " + getConvertedValue<unsigned int, std::string>(source_bundle->id_) \
+                TclThreadManager::error("Error: Circular query (" + this->dumpList(source_bundle->queriers_.getList()) + " " + getConvertedValue<unsigned int, std::string>(source_bundle->id_) \
                             + " -> " + getConvertedValue<unsigned int, std::string>(target_bundle->id_) \
                             + "), couldn't query Tcl-interpreter with ID " + getConvertedValue<unsigned int, std::string>(target_bundle->id_) \
 …
+                    {
                         // It's a query to the CommandExecutor
                         this->debug("TclThread_query -> CE: " + command);
+                        TclThreadManager::debug("TclThread_query -> CE: " + command);
                         if (!CommandExecutor::execute(command, false))
                             this->error("Error: Can't execute command \"" + command + "\"!");
+                            TclThreadManager::error("Error: Can't execute command \"" + command + "\"!");
                         if (CommandExecutor::getLastEvaluation().hasReturnvalue())
 …
+                    {
                         // It's a query to a Tcl interpreter
                         this->debug("TclThread_query: " + command);
                         output = this->eval(target_bundle, command);
+                        TclThreadManager::debug("TclThread_query: " + command);
+                        output = TclThreadManager::eval(target_bundle, command, "query");
+                    }
 …
                     // This happens if the main thread tries to query a busy interpreter
                     // To avoid a lock of the main thread, we simply don't proceed with the query in this case
                     this->error("Error: Couldn't query Tcl-interpreter with ID " + getConvertedValue<unsigned int, std::string>(target_bundle->id_) + ", interpreter is busy right now.");
+                    TclThreadManager::error("Error: Couldn't query Tcl-interpreter with ID " + getConvertedValue<unsigned int, std::string>(target_bundle->id_) + ", interpreter is busy right now.");
+                }
+            }
 …
         return output;
+    }
+    /**
+        @brief Creates a non-interactive Tcl-interpreter which executes a file.
+    */
+    void TclThreadManager::source(const std::string& file)
+    {
+        boost::thread(boost::bind(&sourceThread, file));
+    }
 …
         else
+        {
             this->error("Error: No Tcl-interpreter with ID " + getConvertedValue<unsigned int, std::string>(id) + " existing.");
+            TclThreadManager::error("Error: No Tcl-interpreter with ID " + getConvertedValue<unsigned int, std::string>(id) + " existing.");
             return 0;
+        }
 …
     void TclThreadManager::error(const std::string& error)
+    {
         this->messageQueue_->push_back("error " + error);
+        TclThreadManager::getInstance().messageQueue_->push_back("error " + error);
+    }
 …
     void TclThreadManager::debug(const std::string& error)
+    {
         this->messageQueue_->push_back("debug " + error);
+        TclThreadManager::getInstance().messageQueue_->push_back("debug " + error);
+    }
 …
         Errors are reported through the @ref error function.
     */
     std::string TclThreadManager::eval(TclInterpreterBundle* bundle, const std::string& command)
+    std::string TclThreadManager::eval(TclInterpreterBundle* bundle, const std::string& command, const std::string& action)
+    {
         Tcl_Interp* interpreter = bundle->interpreter_->get();
 …
         if (cc != TCL_OK)
+        {
             this->error("Tcl error (execute, ID " + getConvertedValue<unsigned int, std::string>(bundle->id_) + "): " + static_cast<std::string>(result));
+            TclThreadManager::error("Tcl error (" + action + ", ID " + getConvertedValue<unsigned int, std::string>(bundle->id_) + "): " + static_cast<std::string>(result));
             return "";
+        }
 …
     void tclThread(TclInterpreterBundle* bundle, std::string command)
+    {
         TclThreadManager::getInstance().debug("TclThread_execute: " + command);
         TclThreadManager::getInstance().eval(bundle, command);
+        TclThreadManager::debug("TclThread_execute: " + command);
+        TclThreadManager::eval(bundle, command, "execute");
         bundle->lock_->unlock();
+    }
+    /**
+        @brief The main function of a non-interactive source thread. Executes the file.
+        @param file The name of the file that should be executed by the non-interactive interpreter.
+    */
+    void sourceThread(std::string file)
+    {
+        TclThreadManager::debug("TclThread_source: " + file);
+        // Prepare the command-line arguments
+        const int argc = 2;
+        char* argv[argc];
+        argv[0] = "tclthread";
+        argv[1] = const_cast<char*>(file.c_str());
+        // Start the Tcl-command Tcl_Main with the Tcl_OrxonoxAppInit hook
+        Tcl_Main(argc, argv, Tcl_OrxonoxAppInit);
+//        Tcl::object object(file);
+//        int cc = Tcl_FSEvalFile(bundle->interpreter_->get(), object.get_object());
+//        Tcl::details::result result(bundle->interpreter_->get());
+//        if (cc != TCL_OK)
+//            TclThreadManager::error("Tcl error (source, ID " + getConvertedValue<unsigned int, std::string>(bundle->id_) + "): " + static_cast<std::string>(result));
+//
+//        // Unlock the mutex
+//        bundle->lock_->unlock();
+    }
+    /**
+        @brief A tcl-init hook to inject the non-interactive Tcl-interpreter into the TclThreadManager.
+    */
+    int Tcl_OrxonoxAppInit(Tcl_Interp* interp)
+    {
+        // Create a new interpreter bundle
+        unsigned int id = TclThreadManager::create();
+        TclInterpreterBundle* bundle = TclThreadManager::getInstance().getInterpreterBundle(id);
+        // Replace the default interpreter in the bundle with the non-interactive one (passed as an argument to this function)
+        if (bundle->interpreter_)
+            delete bundle->interpreter_;
+        bundle->interpreter_ = new Tcl::interpreter(interp, true);
+        // Initialize the non-interactive interpreter (like in @ref TclBind::createTclInterpreter but exception safe)
+        std::string libpath = TclBind::getTclLibraryPath();
+        if (libpath != "")
+            TclThreadManager::eval(bundle, "set tcl_library \"" + libpath + "\"", "source");
+        int cc = Tcl_Init(interp);
+        TclThreadManager::eval(bundle, "source \"" + TclBind::getInstance().getTclDataPath() + "/init.tcl\"", "source");
+        // Initialize the non-interactive interpreter also with the thread-specific stuff
+        TclThreadManager::initialize(bundle);
+        // Lock the mutex (this will be locked until the thread finishes - no chance to interact with the interpreter)
+        bundle->lock_->lock();
+        // Return to Tcl_Main
+        if (!bundle->interpreter_)
+            return TCL_ERROR;
+        else
+            return cc;
+    }
+}

code/trunk/src/core/TclThreadManager.h

-                      r3321
+                      r3370
 #include <cassert>
+#include <list>
 #include <map>
 #include <string>
+#include "util/Singleton.h"
 #include "OrxonoxClass.h"
+struct Tcl_Interp;
 namespace orxonox
+{
     class _CoreExport TclThreadManager : public OrxonoxClass
+    class _CoreExport TclThreadManager : public Singleton<TclThreadManager>, public OrxonoxClass
+    {
+        friend class Singleton<TclThreadManager>;
         friend class TclBind;
         friend _CoreExport void tclThread(TclInterpreterBundle* bundle, std::string command);
+        friend _CoreExport void sourceThread(std::string file);
+        friend _CoreExport int Tcl_OrxonoxAppInit(Tcl_Interp* interp);
         public:
             TclThreadManager(Tcl::interpreter* interpreter);
             virtual ~TclThreadManager();
-            static TclThreadManager& getInstance() { assert(TclThreadManager::singletonPtr_s); return *TclThreadManager::singletonPtr_s; }
             static unsigned int      create();
 …
             static void              execute(unsigned int target_id, const std::string& command);
             static std::string       query(unsigned int target_id, const std::string& command);
+            static void              source(const std::string& file);
             void error(const std::string& error);
             void debug(const std::string& error);
+            static void error(const std::string& error);
+            static void debug(const std::string& error);
             void update(const Clock& time);
 …
             std::string dumpList(const std::list<unsigned int>& list);
+            std::string eval(TclInterpreterBundle* bundle, const std::string& command);
+            static void initialize(TclInterpreterBundle* bundle);
+            static std::string eval(TclInterpreterBundle* bundle, const std::string& command, const std::string& action);
             static TclThreadManager* singletonPtr_s;                            ///< Singleton pointer
 …
     _CoreExport void tclThread(TclInterpreterBundle* bundle, std::string command);
+    _CoreExport void sourceThread(std::string file);
+    _CoreExport int Tcl_OrxonoxAppInit(Tcl_Interp* interp);
+}

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

-                      r3331
+                      r3370
     InputHandler InputHandler::EMPTY;
     InputManager* InputManager::singletonRef_s = 0;
+    InputManager* InputManager::singletonPtr_s = 0;
     //! Defines the |= operator for easier use.
 …
         RegisterRootObject(InputManager);
-        assert(singletonRef_s == 0);
-        singletonRef_s = this;
         CCOUT(4) << "Constructing..." << std::endl;
 …
+        }
+        CCOUT(4) << "Construction complete." << std::endl;
         internalState_ = Nothing;
-        CCOUT(4) << "Construction complete." << std::endl;
+    }
 …
         CCOUT(4) << "Destruction complete." << std::endl;
-        singletonRef_s = 0;
+    }

code/trunk/src/core/input/InputManager.h

-                      r3327
+                      r3370
 #include <vector>
+#include "util/Singleton.h"
 #include "core/WindowEventListener.h"
 #include "InputState.h"
 …
           If the OIS::InputManager or the Keyboard fail, an exception is thrown.
     */
     class _CoreExport InputManager : public WindowEventListener
+    class _CoreExport InputManager : public Singleton<InputManager>, public WindowEventListener
+    {
+        friend class Singleton<InputManager>;
     public:
         //! Represents internal states of the InputManager.
 …
             { return this->oisInputManager_; }
-        //! Returns a reference to the singleton instance
-        static InputManager& getInstance() { assert(singletonRef_s); return *singletonRef_s; }
     private: // functions
         // don't mess with a Singleton
 …
         std::set<InputState*>               stateDestroyRequests_; //!< Requests to destroy a state
         static InputManager*                singletonRef_s;        //!< Pointer reference to the singleton
+        static InputManager*                singletonPtr_s;        //!< Pointer reference to the singleton
     };
+}

code/trunk/src/cpptcl/changes_orxonox.diff

-                      r2710
+                      r3370
            Tcl_SetResult(interp, const_cast<char*>(e.what()), TCL_VOLATILE);
            return TCL_ERROR;
-@@ -858,6 +858,18 @@
-      owner_ = true;
+ }
-+interpreter::interpreter(string const &libpath)
-+{
-+     interp_ =  Tcl_CreateInterp();
-+     owner_ = true;
++
-+     try
-+     {
-+        this->eval("set tcl_library \"" + libpath + "\"");
-+        Tcl_Init(this->interp_);
-+     } catch (...) {}
-+}
++
- interpreter::interpreter(Tcl_Interp *interp, bool owner)
+ {
-      interp_ =  interp;
---- cpptcl.h    Wed Jan 28 20:56:11 2009
-+++ cpptcl.h    Sat Jan 24 12:52:54 2009
-@@ -467,6 +467,7 @@
+ {
- public:
-      interpreter();
-+     interpreter(std::string const &libpath);
-      interpreter(Tcl_Interp *, bool owner = true);
-      ~interpreter();

code/trunk/src/cpptcl/cpptcl.cc

-                      r3068
+                      r3370
+}
-interpreter::interpreter(string const &libpath)
+{
-     interp_ =  Tcl_CreateInterp();
-     owner_ = true;
-     try
+     {
-        this->eval("set tcl_library \"" + libpath + "\"");
-        Tcl_Init(this->interp_);
-     } catch (...) {}
+}
 interpreter::interpreter(Tcl_Interp *interp, bool owner)
+{

code/trunk/src/cpptcl/cpptcl.h

r3068	r3370
468	468	public:
469	469	interpreter();
470		~~interpreter(std::string const &libpath);~~
471	470	interpreter(Tcl_Interp *, bool owner = true);
472	471	~interpreter();

code/trunk/src/orxonox/CMakeLists.txt

-                      r3280
+                      r3370
 SET_SOURCE_FILES(ORXONOX_SRC_FILES
   CameraManager.cc
-  GraphicsManager.cc
   LevelManager.cc
   Main.cc
 …
+)
 ADD_SUBDIRECTORY(gamestates)
-ADD_SUBDIRECTORY(gui)
 ADD_SUBDIRECTORY(interfaces)
 ADD_SUBDIRECTORY(objects)
 …
   TOLUA_FILES
     LevelManager.h
-    gui/GUIManager.h
     objects/pickup/BaseItem.h
     objects/pickup/PickupInventory.h
 …
   ${ORXONOX_WIN32}
   LINK_LIBRARIES
+    ${Boost_FILESYSTEM_LIBRARY}
+    ${Boost_SYSTEM_LIBRARY} # Filesystem dependency
+    ${Boost_THREAD_LIBRARY}
+    ${Boost_DATE_TIME_LIBRARY} # Thread dependency
     ${OGRE_LIBRARY}
-    ${CEGUI_LIBRARY}
-    ${LUA_LIBRARIES}
-    ${CEGUILUA_LIBRARY}
-    ${Boost_SYSTEM_LIBRARY}
     ${OPENAL_LIBRARY}
     ${ALUT_LIBRARY}
 …
     ${VORBIS_LIBRARY}
     ${OGG_LIBRARY}
-    ogreceguirenderer_orxonox
     tinyxml++_orxonox
     tolua++_orxonox

code/trunk/src/orxonox/CameraManager.cc

-                      r3280
+                      r3370
 #include "util/StringUtils.h"
 #include "core/GameMode.h"
+#include "core/GUIManager.h"
 #include "core/ObjectList.h"
 #include "tools/Shader.h"
 #include "objects/worldentities/Camera.h"
 #include "objects/Scene.h"
-#include "gui/GUIManager.h"
 namespace orxonox
+{
     CameraManager* CameraManager::singletonRef_s = 0;
+    CameraManager* CameraManager::singletonPtr_s = 0;
     CameraManager::CameraManager(Ogre::Viewport* viewport)
         : viewport_(viewport)
+    {
-        assert(singletonRef_s == 0);
-        singletonRef_s = this;
         this->fallbackCamera_ = 0;
+    }
 …
     CameraManager::~CameraManager()
+    {
-        assert(singletonRef_s != 0);
-        singletonRef_s = 0;
         if (this->fallbackCamera_)
             this->fallbackCamera_->getSceneManager()->destroyCamera(this->fallbackCamera_);

code/trunk/src/orxonox/CameraManager.h

-                      r3196
+                      r3370
 #include <list>
 #include "util/OgreForwardRefs.h"
+#include "util/Singleton.h"
 namespace orxonox
+{
     class _OrxonoxExport CameraManager
+    class _OrxonoxExport CameraManager : public Singleton<CameraManager>
+    {
+            friend class Singleton<CameraManager>;
         public:
             CameraManager(Ogre::Viewport* viewport);
 …
             void useCamera(Ogre::Camera* camera);
+            static CameraManager& getInstance() { assert(singletonRef_s); return *singletonRef_s; }
+            static CameraManager* getInstancePtr() { return singletonRef_s; }
+            static CameraManager* getInstancePtr() { return singletonPtr_s; }
         private:
 …
             Ogre::Camera*         fallbackCamera_;
             static CameraManager* singletonRef_s;
+            static CameraManager* singletonPtr_s;
     };
+}

code/trunk/src/orxonox/LevelManager.cc

-                      r3280
+                      r3370
 #include <map>
+#include <boost/filesystem.hpp>
 #include "core/CommandLine.h"
 #include "core/ConfigValueIncludes.h"
+#include "core/Core.h"
 #include "core/CoreIncludes.h"
+#include "core/Loader.h"
 #include "PlayerManager.h"
 #include "objects/Level.h"
 …
     SetCommandLineArgument(level, "").shortcut("l").information("Default level file (overrides LevelManager::defaultLevelName_ configValue)");
     LevelManager* LevelManager::singletonRef_s = 0;
+    LevelManager* LevelManager::singletonPtr_s = 0;
     LevelManager::LevelManager()
+    {
-        assert(singletonRef_s == 0);
-        singletonRef_s = this;
         RegisterRootObject(LevelManager);
         this->setConfigValues();
 …
     LevelManager::~LevelManager()
+    {
-        assert(singletonRef_s != 0);
-        singletonRef_s = 0;
+    }
 …
+    }
     const std::string& LevelManager::getDefaultLevel()
+    const std::string& LevelManager::getDefaultLevel() const
+    {
         return defaultLevelName_;
+    }
+    std::string LevelManager::getAvailableLevelListItem(unsigned int index) const
+    {
+        if (index >= availableLevels_.size())
+            return std::string();
+        else
+            return availableLevels_[index];
+    }
+    void LevelManager::compileAvailableLevelList()
+    {
+        availableLevels_.clear();
+        boost::filesystem::directory_iterator file(Core::getMediaPathString() + "levels");
+        boost::filesystem::directory_iterator end;
+        while (file != end)
+        {
+            if (!boost::filesystem::is_directory(*file) && file->string()[file->string().length()-1] != '~')
+            {
+                std::string filename = file->path().leaf();
+                if (filename.length() > 4)
+                    availableLevels_.push_back(filename.substr(0,filename.length()-4));
+            }
+            ++file;
+        }
+    }
+}

code/trunk/src/orxonox/LevelManager.h

-                      r3304
+                      r3370
 #include <list>
 #include <string>
+#include "util/Singleton.h"
 #include "core/OrxonoxClass.h"
 …
     class _OrxonoxExport LevelManager
     // tolua_end
         : public OrxonoxClass
+        : public Singleton<LevelManager>, public OrxonoxClass
     { // tolua_export
+            friend class Singleton<LevelManager>;
         public:
             LevelManager();
 …
             void setDefaultLevel(const std::string& levelName); //tolua_export
+            const std::string& getDefaultLevel(); //tolua_export
+            const std::string& getDefaultLevel() const; //tolua_export
+            void compileAvailableLevelList(); //tolua_export
+            std::string getAvailableLevelListItem(unsigned int index) const; //tolua_export
             static LevelManager* getInstancePtr() { return singletonRef_s; }
             static LevelManager& getInstance() { assert(singletonRef_s); return *singletonRef_s; } // tolua_export
+            static LevelManager* getInstancePtr() { return singletonPtr_s; }
+            static LevelManager& getInstance()    { return Singleton<LevelManager>::getInstance(); } // tolua_export
         private:
 …
             std::list<Level*> levels_s;
+            std::vector<std::string> availableLevels_;
             // config values
             std::string defaultLevelName_;
             static LevelManager* singletonRef_s;
+            static LevelManager* singletonPtr_s;
     }; // tolua_export
 } // tolua_export

code/trunk/src/orxonox/Main.cc

-                      r3323
+                      r3370
 #include "util/Debug.h"
 #include "util/Exception.h"
+#include "core/CommandLine.h"
 #include "core/Game.h"
+SetCommandLineSwitch(console).information("Start in console mode (text IO only)");
+// Shortcuts for easy direct loading
+SetCommandLineSwitch(server).information("Start in server mode");
+SetCommandLineSwitch(client).information("Start in client mode");
+SetCommandLineSwitch(dedicated).information("Start in dedicated server mode");
+SetCommandLineSwitch(standalone).information("Start in standalone mode");
 /*
 …
         game->requestState("root");
+        // Some development hacks (not really, but in the future, this calls won't make sense anymore)
+        if (CommandLine::getValue("standalone").getBool())
+            Game::getInstance().requestStates("graphics, standalone, level");
+        else if (CommandLine::getValue("server").getBool())
+            Game::getInstance().requestStates("graphics, server, level");
+        else if (CommandLine::getValue("client").getBool())
+            Game::getInstance().requestStates("graphics, client, level");
+        else if (CommandLine::getValue("dedicated").getBool())
+            Game::getInstance().requestStates("dedicated, level");
+        else if (CommandLine::getValue("console").getBool())
+            Game::getInstance().requestStates("ioConsole");
+        else
+            Game::getInstance().requestStates("graphics, mainMenu");
+    }
     catch (const std::exception& ex)

code/trunk/src/orxonox/OrxonoxPrecompiledHeaders.h

-                      r3322
+                      r3370
 //#include "core/ConfigValueIncludes.h" // 19
 //#include "core/ConsoleCommand.h" // 15
+#include "core/Core.h"
+//#include "core/Core.h" // ?, but not many times
 #include "core/CoreIncludes.h"
-#include "core/GameMode.h"
 #include "core/XMLPort.h"

code/trunk/src/orxonox/OrxonoxPrereqs.h

-                      r3327
+                      r3370
         };
+    }
-    class GraphicsManager;
-    class OgreWindowEventListener;
-    class Settings;
     class RadarViewable;
 …
     class Map;
-    //gui
-    class GUIManager;
     //sound
     class SoundBase;
 …
+}
-namespace CEGUI
+{
-    class DefaultLogger;
-    class Logger;
-    class LuaScriptModule;
-    class OgreCEGUIRenderer;
-    class OgreCEGUIResourceProvider;
-    class OgreCEGUITexture;
+}
 // Bullet Physics Engine
 class btTransform;
 …
 typedef int ALint;
-// Lua
-struct lua_State;
 #endif /* _OrxonoxPrereqs_H__ */

code/trunk/src/orxonox/PawnManager.cc

r3196	r3370
34	34	namespace orxonox
35	35	{
36		PawnManager* PawnManager::singleton~~Ref~~_s = 0;
	36	PawnManager* PawnManager::singletonPtr_s = 0;
37	37
38	38	PawnManager::PawnManager()
39	39	{
40	40	RegisterRootObject(PawnManager);
41
42		~~assert(PawnManager::singletonRef_s == 0);~~
43		~~PawnManager::singletonRef_s = this;~~
44	41	}
45	42
46	43	PawnManager::~PawnManager()
47	44	{
48		~~assert(PawnManager::singletonRef_s != 0);~~
49		~~PawnManager::singletonRef_s = 0;~~
50	45	}
51	46
52	47	void PawnManager::touch()
53	48	{
54		if (!PawnManager::singleton~~Ref~~_s)
	49	if (!PawnManager::singletonPtr_s)
55	50	new PawnManager();
56	51	}

code/trunk/src/orxonox/PawnManager.h

-                      r3196
+                      r3370
 #include "OrxonoxPrereqs.h"
+#include "util/Singleton.h"
 #include "interfaces/Tickable.h"
 namespace orxonox
+{
     class _OrxonoxExport PawnManager : public Tickable
+    class _OrxonoxExport PawnManager : protected Singleton<PawnManager>, public Tickable
+    {
+            friend class Singleton<PawnManager>;
         public:
             static void touch();
 …
             virtual ~PawnManager();
             static PawnManager* singletonRef_s;
+            static PawnManager* singletonPtr_s;
     };
+}

code/trunk/src/orxonox/PlayerManager.cc

r3297	r3370
37	37	namespace orxonox
38	38	{
39		PlayerManager* PlayerManager::singleton~~Ref~~_s = 0;
	39	PlayerManager* PlayerManager::singletonPtr_s = 0;
40	40
41	41	PlayerManager::PlayerManager()
42	42	{
43	43	RegisterRootObject(PlayerManager);
44
45		~~assert(singletonRef_s == 0);~~
46		~~singletonRef_s = this;~~
47	44
48	45	this->getConnectedClients();
…	…
51	48	PlayerManager::~PlayerManager()
52	49	{
53		~~assert(singletonRef_s);~~
54		~~singletonRef_s = 0;~~
55	50	}
56	51

code/trunk/src/orxonox/PlayerManager.h

-                      r3196
+                      r3370
 #include <cassert>
 #include <map>
+#include "util/Singleton.h"
 #include "network/ClientConnectionListener.h"
 namespace orxonox
+{
     class _OrxonoxExport PlayerManager : public ClientConnectionListener
+    class _OrxonoxExport PlayerManager : public Singleton<PlayerManager>, public ClientConnectionListener
+    {
+            friend class Singleton<PlayerManager>;
         public:
             PlayerManager();
             virtual ~PlayerManager();
-            inline static PlayerManager& getInstance()
-                { assert(singletonRef_s); return *singletonRef_s; }
             PlayerInfo* getClient(unsigned int clientID) const;
 …
             std::map<unsigned int, PlayerInfo*> clients_;
             static PlayerManager* singletonRef_s;
+            static PlayerManager* singletonPtr_s;
     };
+}

code/trunk/src/orxonox/gamestates/GSClient.cc

-                      r3280
+                      r3370
     SetCommandLineArgument(ip, "127.0.0.1").information("Sever IP as strin in the form #.#.#.#");
     GSClient::GSClient(const GameStateConstrParams& params)
         : GameState(params)
+    GSClient::GSClient(const GameStateInfo& info)
+        : GameState(info)
         , client_(0)
+    {

code/trunk/src/orxonox/gamestates/GSClient.h

r3280	r3370
40	40	{
41	41	public:
42		GSClient(const GameState~~ConstrParams& params~~);
	42	GSClient(const GameStateInfo& info);
43	43	~GSClient();
44	44

code/trunk/src/orxonox/gamestates/GSDedicated.cc

-                      r3351
+                      r3370
     termios* GSDedicated::originalTerminalSettings_;
     GSDedicated::GSDedicated(const GameStateConstrParams& params)
         : GameState(params)
+    GSDedicated::GSDedicated(const GameStateInfo& info)
+        : GameState(info)
         , server_(0)
         , closeThread_(false)

code/trunk/src/orxonox/gamestates/GSDedicated.h

r3304	r3370
48	48	{
49	49	public:
50		GSDedicated(const GameState~~ConstrParams& params~~);
	50	GSDedicated(const GameStateInfo& info);
51	51	~GSDedicated();
52	52

code/trunk/src/orxonox/gamestates/GSGraphics.cc

-                      r3327
+                      r3370
 #include "GSGraphics.h"
-#include <boost/filesystem.hpp>
-#include <OgreRenderWindow.h>
 #include "util/Convert.h"
 #include "core/Clock.h"
 …
 #include "core/Core.h"
 #include "core/Game.h"
 #include "core/GameMode.h"
+#include "core/GUIManager.h"
 #include "core/input/InputManager.h"
 #include "core/input/KeyBinder.h"
 …
 #include "core/XMLFile.h"
 #include "overlays/console/InGameConsole.h"
-#include "gui/GUIManager.h"
 #include "sound/SoundManager.h"
+#include "GraphicsManager.h"
+// HACK:
+#include "overlays/map/Map.h"
 namespace orxonox
+{
     DeclareGameState(GSGraphics, "graphics", true, true);
+    DeclareGameState(GSGraphics, "graphics", false, true);
+    GSGraphics::GSGraphics(const GameStateConstrParams& params)
+        : GameState(params)
+        , inputManager_(0)
+    GSGraphics::GSGraphics(const GameStateInfo& info)
+        : GameState(info)
         , console_(0)
-        , guiManager_(0)
-        , graphicsManager_(0)
         , soundManager_(0)
         , masterKeyBinder_(0)
 …
         , debugOverlay_(0)
+    {
+        // load master key bindings
+        masterInputState_ = InputManager::getInstance().createInputState("master", true);
+        masterKeyBinder_ = new KeyBinder();
+        masterInputState_->setKeyHandler(masterKeyBinder_);
+    }
     GSGraphics::~GSGraphics()
+    {
+        InputManager::getInstance().destroyState("master");
+        delete this->masterKeyBinder_;
+    }
 …
     void GSGraphics::activate()
+    {
-        GameMode::setShowsGraphics(true);
-        // Load OGRE including the render window
-        this->graphicsManager_ = new GraphicsManager();
         // load debug overlay
         COUT(3) << "Loading Debug Overlay..." << std::endl;
         this->debugOverlay_ = new XMLFile((Core::getMediaPath() / "overlay" / "debug.oxo").string());
+        this->debugOverlay_ = new XMLFile(Core::getMediaPathString() + "overlay/debug.oxo");
         Loader::open(debugOverlay_);
-        // The render window width and height are used to set up the mouse movement.
-        size_t windowHnd = 0;
-        Ogre::RenderWindow* renderWindow = GraphicsManager::getInstance().getRenderWindow();
-        renderWindow->getCustomAttribute("WINDOW", &windowHnd);
-        // Calls the InputManager which sets up the input devices.
-        inputManager_ = new InputManager(windowHnd);
-        // load master key bindings
-        masterInputState_ = InputManager::getInstance().createInputState("master", true);
-        masterKeyBinder_ = new KeyBinder();
         masterKeyBinder_->loadBindings("masterKeybindings.ini");
-        masterInputState_->setKeyHandler(masterKeyBinder_);
         // Load the SoundManager
 …
         console_ = new InGameConsole();
         console_->initialise();
-        // load the CEGUI interface
-        guiManager_ = new GUIManager();
-        guiManager_->initialise(renderWindow);
         // add console command to toggle GUI
 …
 */
-        masterInputState_->setHandler(0);
-        InputManager::getInstance().destroyState("master");
-        delete this->masterKeyBinder_;
-        delete this->guiManager_;
         delete this->console_;
 …
         delete this->soundManager_;
+        delete this->inputManager_;
+        this->inputManager_ = 0;
+        delete graphicsManager_;
+        GameMode::setShowsGraphics(false);
+        // HACK: (destroys a resource smart pointer)
+        Map::hackDestroyMap();
+    }
 …
+        }
-        uint64_t timeBeforeTick = time.getRealMicroseconds();
-        this->inputManager_->update(time);
         this->console_->update(time);
-        uint64_t timeAfterTick = time.getRealMicroseconds();
-        // Also add our tick time
-        Game::getInstance().addTickTime(timeAfterTick - timeBeforeTick);
-        // Process gui events
-        this->guiManager_->update(time);
-        // Render
-        this->graphicsManager_->update(time);
+    }
+}

code/trunk/src/orxonox/gamestates/GSGraphics.h

-                      r3327
+                      r3370
+    {
     public:
         GSGraphics(const GameStateConstrParams& params);
+        GSGraphics(const GameStateInfo& info);
         ~GSGraphics();
 …
     private:
         // managed singletons
-        InputManager*         inputManager_;        //!< Reference to input management
         InGameConsole*        console_;
-        GUIManager*           guiManager_;          //!< Interface to GUI
-        GraphicsManager*      graphicsManager_;     //!< Interface to Ogre
         SoundManager*         soundManager_;        //!< Keeps track of SoundBase objects

code/trunk/src/orxonox/gamestates/GSIOConsole.cc

r3280	r3370
38	38	DeclareGameState(GSIOConsole, "ioConsole", false, false);
39	39
40		GSIOConsole::GSIOConsole(const GameState~~ConstrParams& params~~)
41		: GameState(~~params~~)
	40	GSIOConsole::GSIOConsole(const GameStateInfo& info)
	41	: GameState(info)
42	42	{
43	43	}

code/trunk/src/orxonox/gamestates/GSIOConsole.h

r3280	r3370
38	38	{
39	39	public:
40		GSIOConsole(const GameState~~ConstrParams& params~~);
	40	GSIOConsole(const GameStateInfo& info);
41	41	~GSIOConsole();
42	42

code/trunk/src/orxonox/gamestates/GSLevel.cc

-                      r3327
+                      r3370
 #include "core/GameMode.h"
 #include "core/Core.h"
+#include "core/GraphicsManager.h"
+#include "core/GUIManager.h"
 #include "core/Loader.h"
 #include "core/XMLFile.h"
 …
 #include "objects/quest/QuestManager.h"
 #include "overlays/notifications/NotificationManager.h"
-#include "gui/GUIManager.h"
 #include "CameraManager.h"
-#include "GraphicsManager.h"
 #include "LevelManager.h"
 #include "PlayerManager.h"
 …
 namespace orxonox
+{
     DeclareGameState(GSLevel, "level", false, true);
+    DeclareGameState(GSLevel, "level", false, false);
     SetConsoleCommand(GSLevel, showIngameGUI, true);
     XMLFile* GSLevel::startFile_s = NULL;
     GSLevel::GSLevel(const GameStateConstrParams& params)
         : GameState(params)
+    GSLevel::GSLevel(const GameStateInfo& info)
+        : GameState(info)
         , keyBinder_(0)
         , gameInputState_(0)

code/trunk/src/orxonox/gamestates/GSLevel.h

r3327	r3370
41	41	{
42	42	public:
43		GSLevel(const GameState~~ConstrParams& params~~);
	43	GSLevel(const GameStateInfo& info);
44	44	~GSLevel();
45	45	void setConfigValues();

code/trunk/src/orxonox/gamestates/GSMainMenu.cc

-                      r3327
+                      r3370
 #include "core/Clock.h"
 #include "core/ConsoleCommand.h"
+#include "core/GraphicsManager.h"
+#include "core/GUIManager.h"
 #include "objects/Scene.h"
-#include "gui/GUIManager.h"
 #include "sound/SoundMainMenu.h"
-#include "GraphicsManager.h"
 namespace orxonox
 …
     DeclareGameState(GSMainMenu, "mainMenu", false, true);
     GSMainMenu::GSMainMenu(const GameStateConstrParams& params)
         : GameState(params)
+    GSMainMenu::GSMainMenu(const GameStateInfo& info)
+        : GameState(info)
         , inputState_(0)
+    {
+    }
-    GSMainMenu::~GSMainMenu()
+    {
+    }
-    void GSMainMenu::activate()
+    {
         inputState_ = InputManager::getInstance().createInputState("mainMenu");
 …
         // and a Camera
         this->camera_ = this->scene_->getSceneManager()->createCamera("mainMenu/Camera");
+    }
+    GSMainMenu::~GSMainMenu()
+    {
+        InputManager::getInstance().destroyState("mainMenu");
+        this->scene_->getSceneManager()->destroyCamera(this->camera_);
+        delete this->scene_;
+    }
+    void GSMainMenu::activate()
+    {
         // show main menu
         GUIManager::getInstance().showGUI("mainmenu_3");
+        GUIManager::getInstance().showGUI("mainmenu_4");
         GUIManager::getInstance().setCamera(this->camera_);
         GraphicsManager::getInstance().setCamera(this->camera_);
 …
         InputManager::getInstance().leaveState("mainMenu");
-        InputManager::getInstance().destroyState("mainMenu");
         GUIManager::getInstance().setCamera(0);
         GraphicsManager::getInstance().setCamera(0);
-        this->scene_->getSceneManager()->destroyCamera(this->camera_);
-        delete this->scene_;
 /*

code/trunk/src/orxonox/gamestates/GSMainMenu.h

r3327	r3370
40	40	{
41	41	public:
42		GSMainMenu(const GameState~~ConstrParams& params~~);
	42	GSMainMenu(const GameStateInfo& info);
43	43	~GSMainMenu();
44	44

code/trunk/src/orxonox/gamestates/GSRoot.cc

-                      r3304
+                      r3370
 #include "core/Clock.h"
-#include "core/CommandLine.h"
 #include "core/ConsoleCommand.h"
 #include "core/Game.h"
 #include "core/GameMode.h"
+#include "core/LuaBind.h"
 #include "network/NetworkFunction.h"
+#include "ToluaBindCore.h"
+#include "ToluaBindOrxonox.h"
 #include "tools/Timer.h"
 #include "interfaces/TimeFactorListener.h"
 …
 namespace orxonox
+{
+    DeclareGameState(GSRoot, "root", true, false);
+    SetCommandLineSwitch(console).information("Start in console mode (text IO only)");
+    // Shortcuts for easy direct loading
+    SetCommandLineSwitch(server).information("Start in server mode");
+    SetCommandLineSwitch(client).information("Start in client mode");
+    SetCommandLineSwitch(dedicated).information("Start in dedicated server mode");
+    SetCommandLineSwitch(standalone).information("Start in standalone mode");
+    DeclareGameState(GSRoot, "root", false, false);
     GSRoot::GSRoot(const GameStateConstrParams& params)
         : GameState(params)
+    GSRoot::GSRoot(const GameStateInfo& info)
+        : GameState(info)
         , timeFactor_(1.0f)
         , bPaused_(false)
 …
         this->ccSetTimeFactor_ = 0;
         this->ccPause_ = 0;
+        // Tell LuaBind about all tolua interfaces
+        LuaBind::getInstance().addToluaInterface(&tolua_Core_open, "Core");
+        LuaBind::getInstance().addToluaInterface(&tolua_Orxonox_open, "Orxonox");
+    }
 …
         // create the global LevelManager
         this->levelManager_ = new LevelManager();
-        // Load level directly?
-        bool loadLevel = false;
-        if (CommandLine::getValue("standalone").getBool())
+        {
-            Game::getInstance().requestStates("graphics, standalone, level");
-            loadLevel = true;
+        }
-        if (CommandLine::getValue("server").getBool())
+        {
-            Game::getInstance().requestStates("graphics, server, level");
-            loadLevel = true;
+        }
-        if (CommandLine::getValue("client").getBool())
+        {
-            Game::getInstance().requestStates("graphics, client, level");
-            loadLevel = true;
+        }
-        if (CommandLine::getValue("dedicated").getBool())
+        {
-            Game::getInstance().requestStates("dedicated, level");
-            loadLevel = true;
+        }
-        // Determine where to start otherwise
-        if (!loadLevel && !CommandLine::getValue("console").getBool())
+        {
-            // Also load graphics
-            Game::getInstance().requestState("graphics");
+        }
+    }
 …
+        }
-        uint64_t timeBeforeTick = time.getRealMicroseconds();
         for (ObjectList<TimerBase>::iterator it = ObjectList<TimerBase>::begin(); it; ++it)
             it->tick(time);
 …
             it->tick(leveldt * this->timeFactor_);
         /*** HACK *** HACK ***/
-        uint64_t timeAfterTick = time.getRealMicroseconds();
-        // Also add our tick time
-        Game::getInstance().addTickTime(timeAfterTick - timeBeforeTick);
+    }
 …
     @brief
         Changes the speed of Orxonox
+    @remark
+        This function is a hack when placed here!
+        Timefactor should be related to the scene (level or so), not the game
     */
     void GSRoot::setTimeFactor(float factor)

code/trunk/src/orxonox/gamestates/GSRoot.h

r3280	r3370
38	38	{
39	39	public:
40		GSRoot(const GameState~~ConstrParams& params~~);
	40	GSRoot(const GameStateInfo& info);
41	41	~GSRoot();
42	42

code/trunk/src/orxonox/gamestates/GSServer.cc

-                      r3280
+                      r3370
     SetCommandLineArgument(port, 55556).shortcut("p").information("Network communication port to be used 0-65535 (default: 55556)");
     GSServer::GSServer(const GameStateConstrParams& params)
         : GameState(params)
+    GSServer::GSServer(const GameStateInfo& info)
+        : GameState(info)
         , server_(0)
+    {

code/trunk/src/orxonox/gamestates/GSServer.h

r3280	r3370
40	40	{
41	41	public:
42		GSServer(const GameState~~ConstrParams& params~~);
	42	GSServer(const GameStateInfo& info);
43	43	~GSServer();
44	44

code/trunk/src/orxonox/gamestates/GSStandalone.cc

r3280	r3370
36	36	DeclareGameState(GSStandalone, "standalone", false, true);
37	37
38		GSStandalone::GSStandalone(const GameState~~ConstrParams& params~~)
39		: GameState(~~params~~)
	38	GSStandalone::GSStandalone(const GameStateInfo& info)
	39	: GameState(info)
40	40	{
41	41	}

code/trunk/src/orxonox/gamestates/GSStandalone.h

r3280	r3370
38	38	{
39	39	public:
40		GSStandalone(const GameState~~ConstrParams& params~~);
	40	GSStandalone(const GameStateInfo& info);
41	41	~GSStandalone();
42	42

code/trunk/src/orxonox/objects/pickup/BaseItem.h

-                      r3196
+                      r3370
             Daniel 'Huty' Haggenmueller
     */
+    class _OrxonoxExport BaseItem
+// tolua_end
+        : public BaseObject
+// tolua_begin
+    class _OrxonoxExport BaseItem : public BaseObject
+    {
 // tolua_end

code/trunk/src/orxonox/objects/pickup/PickupInventory.cc

-                      r3327
+                      r3370
 #include "core/ConsoleCommand.h"
+#include "core/GUIManager.h"
 #include "core/input/InputManager.h"
-#include "gui/GUIManager.h"
 #include "objects/controllers/HumanController.h"
 #include "objects/worldentities/pawns/Pawn.h"

code/trunk/src/orxonox/objects/pickup/PickupInventory.h

-                      r3196
+                      r3370
 namespace orxonox
+{
-// tolua_end
     /**
         @brief Static class for the inventory GUI window.
         @author Daniel 'Huty' Haggenmueller
     */
-// tolua_begin
     class _OrxonoxExport PickupInventory
+    {

code/trunk/src/orxonox/objects/pickup/PickupSpawner.cc

-                      r3325
+                      r3370
 #include "core/CoreIncludes.h"
+#include "core/GUIManager.h"     // HACK; see below
 #include "core/Template.h"
 #include "core/XMLPort.h"
-#include "gui/GUIManager.h"     // HACK; see below
 #include "objects/worldentities/pawns/Pawn.h"
 #include "PickupInventory.h"    // HACK; Only for hack, remove later

code/trunk/src/orxonox/objects/quest/QuestDescription.h

-                      r3196
+                      r3370
         Damian 'Mozork' Frick
     */
+    class _OrxonoxExport QuestDescription
+    class _OrxonoxExport QuestDescription : public BaseObject
+    {
 // tolua_end
-        : public BaseObject
-    { // tolua_export
         public:
             QuestDescription(BaseObject* creator);

code/trunk/src/orxonox/objects/quest/QuestListener.cc

-                      r3280
+                      r3370
     /**
     @brief
         Makes all QuestListener in the list aware that a certain status change has occured and executes them if the status change affects them.
+        Makes all QuestListener in the list aware that a certain status change has occurred and executes them if the status change affects them.
     @param listeners
         The list of QuestListeners that have to be made aware of the status change.
 …
         else
+        {
             COUT(1) << "An unforseen, never to happen, Error has occured. This is impossible!" << std::endl;
+            COUT(1) << "An unforseen, never to happen, Error has occurred. This is impossible!" << std::endl;
         return "";
+        }

code/trunk/src/orxonox/objects/quest/QuestManager.cc

-                      r3325
+                      r3370
 #include "util/Exception.h"
 #include "core/CoreIncludes.h"
-#include "gui/GUIManager.h"
 #include "objects/infos/PlayerInfo.h"
 …
+{
     //! Pointer to the current (and single) instance of this class.
     /*static*/ QuestManager* QuestManager::singletonRef_s = NULL;
+    /*static*/ QuestManager* QuestManager::singletonPtr_s = NULL;
     /**
 …
+    {
         RegisterRootObject(QuestManager);
-        assert(singletonRef_s == 0);
-        singletonRef_s = this;
+    }
 …
+    {
+    }
-    /**
-    @brief
-        Returns a reference to the current (and single) instance of the QuestManager, and creates one if there isn't one to begin with.
-    @return
-        Returns a reference to the single instance of the Quest Manager.
-    */
-    /*static*/ QuestManager & QuestManager::getInstance()
+    {
-        assert(singletonRef_s);
-        return *singletonRef_s;
+    }
 …
     QuestContainer* QuestManager::getQuestTree(std::string & name)
+    {
+        GUIOverlay* gui = GUIManager::getInstance().getOverlay(name);
+        GUIOverlay* gui = NULL;
+        for (ObjectList<GUIOverlay>::iterator it = ObjectList<GUIOverlay>::begin(); it != ObjectList<GUIOverlay>::end(); ++it)
+            if (it->getGUIName() == name)
+                gui = *it;
         PlayerInfo* player;
 …
+        {
             container->status = "";
             COUT(1) << "An error occured. A Quest of un-specified status wanted to be displayed." << std::endl;
+            COUT(1) << "An error occurred. A Quest of un-specified status wanted to be displayed." << std::endl;
+        }

code/trunk/src/orxonox/objects/quest/QuestManager.h

-                      r3196
+                      r3370
 #include <map>
 #include <string>
+#include "util/Singleton.h"
 #include "core/OrxonoxClass.h"
 …
         Damian 'Mozork' Frick
     */
+    class _OrxonoxExport QuestManager
+// tolua_end
+        : public OrxonoxClass
+// tolua_begin
+    class _OrxonoxExport QuestManager : public Singleton<QuestManager>, public orxonox::OrxonoxClass
+    {
 // tolua_end
+            friend class Singleton<QuestManager>;
         public:
             QuestManager();
             virtual ~QuestManager();
+            static QuestManager& getInstance(); // tolua_export //!< Returns a reference to the single instance of the Quest Manager.
+            //! Returns a reference to the single instance of the Quest Manager.
+            static QuestManager& getInstance() { return Singleton<QuestManager>::getInstance(); } // tolua_export
             bool registerQuest(Quest* quest); //!< Registers a Quest in the QuestManager.
 …
         private:
             static QuestManager* singletonRef_s;
+            static QuestManager* singletonPtr_s;
             std::map<std::string, Quest*> questMap_; //!< All Quests registered by their id's.

code/trunk/src/orxonox/overlays/GUIOverlay.cc

-                      r3327
+                      r3370
 #include "core/input/InputManager.h"
 #include "core/CoreIncludes.h"
+#include "core/GUIManager.h"
 #include "core/XMLPort.h"
-#include "gui/GUIManager.h"
 namespace orxonox
 …
         XMLPortParam(GUIOverlay, "guiname", setGUIName, getGUIName, xmlElement, mode);
-        GUIManager::getInstance().registerOverlay(this->guiName_, this);
+    }

code/trunk/src/orxonox/overlays/console/InGameConsole.cc

-                      r3327
+                      r3370
     SetConsoleCommand(InGameConsole, closeConsole, true);
     InGameConsole* InGameConsole::singletonRef_s = 0;
+    InGameConsole* InGameConsole::singletonPtr_s = 0;
     /**
 …
         RegisterObject(InGameConsole);
-        assert(singletonRef_s == 0);
-        singletonRef_s = this;
         this->bActive_ = false;
         this->cursor_ = 0.0f;
 …
         if (this->consoleOverlay_)
             Ogre::OverlayManager::getSingleton().destroy(consoleOverlay_);
-        singletonRef_s = 0;
+    }

code/trunk/src/orxonox/overlays/console/InGameConsole.h

-                      r3327
+                      r3370
 #include <string>
 #include "util/OgreForwardRefs.h"
+#include "util/Singleton.h"
 #include "core/Shell.h"
 #include "core/WindowEventListener.h"
 …
 namespace orxonox
+{
     class _OrxonoxExport InGameConsole : public ShellListener, public WindowEventListener
+    class _OrxonoxExport InGameConsole : public Singleton<InGameConsole>, public ShellListener, public WindowEventListener
+    {
+        friend class Singleton<InGameConsole>;
     public: // functions
         InGameConsole();
 …
         void update(const Clock& time);
-        static InGameConsole& getInstance() { assert(singletonRef_s); return *singletonRef_s; }
-        static InGameConsole* getInstancePtr() { return singletonRef_s; }
         static void openConsole();
 …
         bool bHidesAllInput_;
         static InGameConsole* singletonRef_s;
+        static InGameConsole* singletonPtr_s;
     };
+}

code/trunk/src/orxonox/overlays/notifications/NotificationManager.cc

-                      r3196
+                      r3370
     const std::string NotificationManager::NONE = "none";
     NotificationManager* NotificationManager::singletonRef_s = NULL;
+    NotificationManager* NotificationManager::singletonPtr_s = NULL;
     /**
 …
+    {
         RegisterRootObject(NotificationManager);
-        assert(singletonRef_s == 0);
-        singletonRef_s = this;
         this->highestIndex_ = 0;
 …
+    }
-    /**
-    @brief
-        Returns the current (and single) instance of the NotificationManager. Creates one, if there isn't one to begin with.
-    @return
-        Returns a reference to the single instance of the NotificationManager.
-    */
-    /*static*/ NotificationManager & NotificationManager::getInstance()
+    {
-        assert(singletonRef_s);
-        return *singletonRef_s;
+    }
     /**
     @brief

code/trunk/src/orxonox/overlays/notifications/NotificationManager.h

-                      r3196
+                      r3370
 #include <map>
 #include <string>
+#include "util/Singleton.h"
 #include "core/OrxonoxClass.h"
 …
         Damian 'Mozork' Frick
     */
     class _OrxonoxExport NotificationManager : public OrxonoxClass
+    class _OrxonoxExport NotificationManager : public Singleton<NotificationManager>, public OrxonoxClass
+    {
+            friend class Singleton<NotificationManager>;
         public:
             NotificationManager();
 …
             static const std::string ALL;
             static const std::string NONE;
-            static NotificationManager & getInstance(); //! Returns a reference to the single instance of the NotificationManager.
             bool registerNotification(Notification* notification); //!< Registers a Notification within the NotificationManager.
 …
         private:
             static NotificationManager* singletonRef_s;
+            static NotificationManager* singletonPtr_s;
             int highestIndex_; //!< This variable holds the highest index (resp. key) in notificationLists_s, to secure that  no key appears twice.

code/trunk/src/orxonox/sound/SoundBase.cc

-                      r3196
+                      r3370
     void SoundBase::update() {
         if(this->entity_ != NULL && alIsSource(this->source_)) {
             Vector3 pos = this->entity_->getPosition();
+            const Vector3& pos = this->entity_->getPosition();
             alSource3f(this->source_, AL_POSITION, pos.x, pos.y, pos.z);
             ALenum error = alGetError();
 …
                 COUT(2) << "Sound: OpenAL: Invalid sound position" << std::endl;
             Vector3 vel = this->entity_->getVelocity();
+            const Vector3& vel = this->entity_->getVelocity();
             alSource3f(this->source_, AL_VELOCITY, vel.x, vel.y, vel.z);
             error = alGetError();
 …
                 COUT(2) << "Sound: OpenAL: Invalid sound velocity" << std::endl;
             Quaternion orient = this->entity_->getOrientation();
+            const Quaternion& orient = this->entity_->getOrientation();
             Vector3 at = orient.zAxis();
             alSource3f(this->source_, AL_DIRECTION, at.x, at.y, at.z);
 …
         if(ov_open(f, &vf, NULL, 0) < 0)
+        {
             COUT(2) << "Sound: libvorbisfile: File seems not to be an Ogg Vorbis bitstream" << std::endl;
+            COUT(2) << "Sound: libvorbisfile: File does not seem to be an Ogg Vorbis bitstream" << std::endl;
             ov_clear(&vf);
             return AL_NONE;

code/trunk/src/orxonox/sound/SoundManager.cc

-                      r3280
+                      r3370
 namespace orxonox
+{
     SoundManager* SoundManager::singletonRef_s = NULL;
+    SoundManager* SoundManager::singletonPtr_s = NULL;
     /**
 …
     SoundManager::SoundManager()
+    {
-        assert(singletonRef_s == NULL);
-        singletonRef_s = this;
         this->device_ = NULL;
         this->soundavailable_ = true;
 …
     SoundManager::~SoundManager()
+    {
-        assert(singletonRef_s != NULL);
-        singletonRef_s = NULL;
         alcDestroyContext(this->context_);
         alcCloseDevice(this->device_);
 …
         // update listener orientation
         Quaternion orient = camera->getOrientation();
+        const Quaternion& orient = camera->getOrientation();
         Vector3 up = orient.xAxis(); // just a wild guess
         Vector3 at = orient.zAxis();

code/trunk/src/orxonox/sound/SoundManager.h

-                      r3280
+                      r3370
 #include <cassert>
 #include <list>
+#include "util/Singleton.h"
 #include "interfaces/Tickable.h"
 …
+     *
      */
     class _OrxonoxExport SoundManager : public Tickable
+    class _OrxonoxExport SoundManager : public Singleton<SoundManager>, public Tickable
+    {
+        friend class Singleton<SoundManager>;
     public:
         SoundManager();
 …
         bool isSoundAvailable();
-        static SoundManager& getInstance() { assert(singletonRef_s); return *singletonRef_s; }
     private:
         ALCdevice* device_;
 …
         bool soundavailable_;
         static SoundManager* singletonRef_s;
+        static SoundManager* singletonPtr_s;
     }; // class SoundManager
 } // namespace orxonox

code/trunk/src/orxonox/tools/ParticleInterface.cc

-                      r3301
+                      r3370
 #include "util/Math.h"
 #include "core/CoreIncludes.h"
+#include "core/ConfigValueIncludes.h"
 #include "core/GameMode.h"
-#include "GraphicsManager.h"
 namespace orxonox
 …
+    }
+    void ParticleInterface::setConfigValues()
+    {
+        SetConfigValue(globalDetailLevel_, 2)
+            .description("O: off, 1: low, 2: normal, 3: high").callback(this, &ParticleInterface::detailLevelChanged);
+    }
     Ogre::ParticleEmitter* ParticleInterface::createNewEmitter()
+    {
 …
         this->detaillevel_ = level;
         if (GameMode::showsGraphics())
             this->detailLevelChanged(GraphicsManager::getInstance().getDetailLevelParticle());
+    }
     void ParticleInterface::detailLevelChanged(unsigned int newlevel)
+    {
         if (newlevel >= static_cast<unsigned int>(this->detaillevel_))
+            this->detailLevelChanged();
+    }
+    void ParticleInterface::detailLevelChanged()
+    {
+        if (this->globalDetailLevel_ >= this->detaillevel_)
             this->bAllowedByLOD_ = true;
         else

code/trunk/src/orxonox/tools/ParticleInterface.h

-                      r3280
+                      r3370
             ParticleInterface(Ogre::SceneManager* scenemanager, const std::string& templateName, LODParticle::Value detaillevel);
             virtual ~ParticleInterface();
+            void setConfigValues();
             inline Ogre::ParticleSystem* getParticleSystem()
 …
                 { return this->bVisible_; }
-            void detailLevelChanged(unsigned int newlevel);
             void setDetailLevel(unsigned int level);
 …
         private:
             void updateVisibility();
+            void detailLevelChanged();
             Ogre::ParticleSystem*     particleSystem_;
 …
             bool                      bEnabled_;
             bool                      bAllowedByLOD_;
             unsigned int              detaillevel_;     //!< Detail level of this particle effect (0: off, 1: low, 2: normal, 3: high)
+            unsigned int              detaillevel_;       //!< Detail level of this particle effect (0: off, 1: low, 2: normal, 3: high)
             float                     speedFactor_;
+            // config values
+            unsigned int              globalDetailLevel_; //!< Global maximum detail level of particle effects (0: off, 1: low, 2: normal, 3: high)
             static ParticleInterface* currentParticleInterface_s;

code/trunk/src/orxonox/tools/Shader.cc

r3301	r3370
41	41	#include "core/CoreIncludes.h"
42	42	#include "core/GameMode.h"
43		#include "GraphicsManager.h"
	43	#include "core/GraphicsManager.h"
44	44
45	45	namespace orxonox

code/trunk/src/util/ScopeGuard.h

-                      r3280
+                      r3370
+        }
-    protected:
         ScopeGuardImpl0(F fun) : fun_(fun)
         {}
+    protected:
         F fun_;
     };
 …
+        }
-    protected:
         ScopeGuardImpl1(F fun, P1 p1) : fun_(fun), p1_(p1)
         {}
+    protected:
         F fun_;
         const P1 p1_;
 …
+        }
-    protected:
         ScopeGuardImpl2(F fun, P1 p1, P2 p2) : fun_(fun), p1_(p1), p2_(p2)
         {}
+    protected:
         F fun_;
         const P1 p1_;
 …
+        }
-    protected:
         ScopeGuardImpl3(F fun, P1 p1, P2 p2, P3 p3) : fun_(fun), p1_(p1), p2_(p2), p3_(p3)
         {}
+    protected:
         F fun_;
         const P1 p1_;
 …
+        }
-    protected:
         ScopeGuardImpl4( F fun, P1 p1, P2 p2, P3 p3, P4 p4 ) :
              fun_( fun ), p1_( p1 ), p2_( p2 ), p3_( p3 ), p4_( p4 )
         {}
+    protected:
         F fun_;
         const P1 p1_;
 …
+        }
-    protected:
         ScopeGuardImpl5( F fun, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5 ) :
              fun_( fun ), p1_( p1 ), p2_( p2 ), p3_( p3 ), p4_( p4 ), p5_( p5 )
         {}
+    protected:
         F fun_;
         const P1 p1_;
 …
+        }
-    protected:
         ObjScopeGuardImpl0(Obj& obj, MemFun memFun) : obj_(obj), memFun_(memFun)
         {}
+    protected:
         Obj& obj_;
         MemFun memFun_;
 …
+        }
-    protected:
         ObjScopeGuardImpl1(Obj& obj, MemFun memFun, P1 p1) : obj_(obj), memFun_(memFun), p1_(p1)
         {}
+    protected:
         Obj& obj_;
         MemFun memFun_;
 …
+        }
-    protected:
         ObjScopeGuardImpl2(Obj& obj, MemFun memFun, P1 p1, P2 p2) : obj_(obj), memFun_(memFun), p1_(p1), p2_(p2)
         {}
+    protected:
         Obj& obj_;
         MemFun memFun_;
 …
+        }
-    protected:
         ObjScopeGuardImpl3( Obj & obj, MemFun memFun, P1 p1, P2 p2, P3 p3 ) :
              obj_( obj ), memFun_( memFun ), p1_( p1 ), p2_( p2 ), p3_( p3 )
         {}
+    protected:
         Obj& obj_;
         MemFun memFun_;

code/trunk/src/util/SignalHandler.cc

r3301	r3370
41	41	namespace orxonox
42	42	{
43		SignalHandler* SignalHandler::singleton~~Ref~~_s = NULL;
	43	SignalHandler* SignalHandler::singletonPtr_s = NULL;
44	44	}
45	45
…	…
122	122	}
123	123	// if the signalhandler has already been destroyed then don't do anything
124		if( SignalHandler::singleton~~Ref~~_s == 0 )
	124	if( SignalHandler::singletonPtr_s == 0 )
125	125	{
126	126	COUT(0) << "recieved signal " << sigName.c_str() << std::endl << "can't write backtrace because SignalHandler already destroyed" << std::endl;

code/trunk/src/util/SignalHandler.h

-                      r3068
+                      r3370
 #include <list>
 #include <string>
+#include "Singleton.h"
 namespace orxonox
 …
     typedef std::list<SignalCallbackRec> SignalCallbackList;
     class SignalHandler
+    class SignalHandler : public Singleton<SignalHandler>
+    {
+        friend class Singleton<SignalHandler>;
     public:
+        SignalHandler()  { assert(SignalHandler::singletonRef_s == 0); SignalHandler::singletonRef_s = this; }
+        ~SignalHandler() { assert(SignalHandler::singletonRef_s != 0); SignalHandler::singletonRef_s = NULL; }
+        inline static SignalHandler& getInstance() { assert(SignalHandler::singletonRef_s); return *SignalHandler::singletonRef_s; }
+        SignalHandler()  { }
+        ~SignalHandler() { }
         void registerCallback( SignalCallback cb, void * someData );
 …
         SignalCallbackList callbackList;
         static SignalHandler* singletonRef_s;
+        static SignalHandler* singletonPtr_s;
         std::string appName;
 …
 namespace orxonox
+{
     class _UtilExport SignalHandler
+    class _UtilExport SignalHandler : public Singleton<SignalHandler>
+    {
+        friend class Singleton<SignalHandler>;
     public:
+        SignalHandler()  { assert(SignalHandler::singletonRef_s == 0); SignalHandler::singletonRef_s = this; }
+        ~SignalHandler() { assert(SignalHandler::singletonRef_s != 0); SignalHandler::singletonRef_s = 0; }
+        inline static SignalHandler& getInstance() { assert(SignalHandler::singletonRef_s); return *SignalHandler::singletonRef_s; }
+        SignalHandler()  { }
+        ~SignalHandler() { }
         void doCatch( const std::string & appName, const std::string & filename ) {}
         void dontCatch() {}
 …
     private:
         static SignalHandler* singletonRef_s;
+        static SignalHandler* singletonPtr_s;
     };
+}

Context Navigation

Legend:

Download in other formats: