Changeset 5929 for code/trunk/src

code/trunk

Property svn:mergeinfo changed
/code/branches/core5 (added) merged: 5768-5769,5772,5775-5780,5783-5785,5791-5792,5795-5807,5809-5814,5816-5832,5836-5839,5842-5853,5855-5899,5904-5922,5924-5928

code/trunk/src/Orxonox.cc

-                      r5752
+                      r5929
         for (int i = 1; i < argc; ++i)
             strCmdLine += argv[i] + std::string(" ");
+#endif
         return orxonox::main(strCmdLine);
-#endif
+    }
     catch (...)

code/trunk/src/OrxonoxConfig.cmake

-                      r5695
+                      r5929
   OPTION(PCH_ENABLE "Global PCH switch" TRUE)
 ENDIF()
+# Global switch to disable multiple file compilations
+OPTION(DISABLE_COMPILATIONS "Global multi-file compilation switch" FALSE)
 # Use WinMain() or main()?

code/trunk/src/external/bullet/BulletCollision/CMakeLists.txt

-                      r5781
+                      r5929
 ADD_SOURCE_FILES(BULLET_FILES
+COMPILATION_BEGIN BulletCollisionCompilation.cpp
         BroadphaseCollision/btAxisSweep3.cpp
         BroadphaseCollision/btBroadphaseProxy.cpp
 …
         Gimpact/btContactProcessing.cpp
         Gimpact/btGImpactShape.cpp
-        Gimpact/gim_contact.cpp
         Gimpact/btGImpactBvh.cpp
         Gimpact/btGenericPoolAllocator.cpp
-        Gimpact/gim_memory.cpp
         Gimpact/btGImpactCollisionAlgorithm.cpp
         Gimpact/btTriangleShapeEx.cpp
-        Gimpact/gim_tri_collision.cpp
         Gimpact/btGImpactQuantizedBvh.cpp
-        Gimpact/gim_box_set.cpp
         NarrowPhaseCollision/btContinuousConvexCollision.cpp
 …
         NarrowPhaseCollision/btSubSimplexConvexCast.cpp
         NarrowPhaseCollision/btVoronoiSimplexSolver.cpp
+COMPILATION_END
+COMPILATION_BEGIN BulletGImpactCompilation.cpp
+        Gimpact/gim_contact.cpp
+        Gimpact/gim_memory.cpp
+        Gimpact/gim_tri_collision.cpp
+        Gimpact/gim_box_set.cpp
+COMPILATION_END
         # Headers

code/trunk/src/external/bullet/BulletDynamics/CMakeLists.txt

-                      r5781
+                      r5929
 ADD_SOURCE_FILES(BULLET_FILES
+COMPILATION_BEGIN BulletDynamicsCompilation.cpp
         ConstraintSolver/btContactConstraint.cpp
         ConstraintSolver/btConeTwistConstraint.cpp
 …
         Character/btKinematicCharacterController.cpp
+COMPILATION_END
         # Headers

code/trunk/src/external/bullet/CMakeLists.txt

-                      r5781
+                      r5929
 ADD_SUBDIRECTORY(LinearMath)
-# No warnings needed from third party libraries
-REMOVE_COMPILER_FLAGS("-W3 -W4" MSVC)
-ADD_COMPILER_FLAGS("-w")
 ORXONOX_ADD_LIBRARY(bullet_orxonox
   ORXONOX_EXTERNAL
   NO_DLL_INTERFACE
-  PCH_FILE
-    BulletPrecompiledHeaders.h
   VERSION
 .74

code/trunk/src/external/bullet/LinearMath/CMakeLists.txt

-                      r5781
+                      r5929
 ADD_SOURCE_FILES(BULLET_FILES
+COMPILATION_BEGIN BulletLinearMathCompilation.cpp
                 btConvexHull.cpp
                 btQuickprof.cpp
                 btGeometryUtil.cpp
                 btAlignedAllocator.cpp
+COMPILATION_END
                 # Headers

code/trunk/src/external/ceguilua/CMakeLists.txt

-                      r5781
+                      r5929
+)
-# No warnings needed from third party libraries
-REMOVE_COMPILER_FLAGS("-W3 -W4" MSVC)
-ADD_COMPILER_FLAGS("-w")
 SOURCE_GROUP("Source" FILES ${CEGUILUA_FILES})

code/trunk/src/external/cpptcl/CMakeLists.txt

-                      r5781
+                      r5929
+)
-# No warnings needed from third party libraries
-REMOVE_COMPILER_FLAGS("-W3 -W4" MSVC)
-ADD_COMPILER_FLAGS("-w")
 ORXONOX_ADD_LIBRARY(cpptcl_orxonox
   ORXONOX_EXTERNAL

code/trunk/src/external/ogreceguirenderer/CMakeLists.txt

-                      r5781
+                      r5929
+ #
 SET(OCR_FILES
+SET_SOURCE_FILES(OCR_FILES
   OgreCEGUIRenderer.h
   OgreCEGUIResourceProvider.h
   OgreCEGUITexture.h
+COMPILATION_BEGIN OgreCEGUIRendererCompilation.cpp
   OgreCEGUIRenderer.cpp
   OgreCEGUIResourceProvider.cpp
   OgreCEGUITexture.cpp
+COMPILATION_END
+)
-# No warnings needed from third party libraries
-REMOVE_COMPILER_FLAGS("-W3 -W4" MSVC)
-ADD_COMPILER_FLAGS("-w")
 ORXONOX_ADD_LIBRARY(ogreceguirenderer_orxonox

code/trunk/src/external/ois/CMakeLists.txt

-                      r5781
+                      r5929
   OISPrereqs.h
+COMPILATION_BEGIN OISCompilation.cpp
   OISEffect.cpp
   OISException.cpp
 …
   OISKeyboard.cpp
   OISObject.cpp
+COMPILATION_END
+)
 IF(WIN32)
 …
   ADD_SUBDIRECTORY(linux)
 ENDIF()
-# No warnings needed from third party libraries
-REMOVE_COMPILER_FLAGS("-W3 -W4" MSVC)
-ADD_COMPILER_FLAGS("-w")
 INCLUDE_DIRECTORIES(.)

code/trunk/src/external/ois/changes_orxonox.diff

-                      r5781
+                      r5929
+--- win32/Win32ForceFeedback.cpp
++++ win32/Win32ForceFeedback.cpp
+@@ -25,7 +25,7 @@
+ #include <Math.h>
+ // 0 = No trace; 1 = Important traces; 2 = Debug traces
+-#define OIS_WIN32_JOYFF_DEBUG 1
++#define OIS_WIN32_JOYFF_DEBUG 0
+ #if (defined (_DEBUG) || defined(OIS_WIN32_JOYFF_DEBUG))
+   #include <iostream>

code/trunk/src/external/ois/linux/CMakeLists.txt

-                      r5781
+                      r5929
   LinuxPrereqs.h
+COMPILATION_BEGIN OISLinuxCompilation.cpp
   EventHelpers.cpp
   LinuxForceFeedback.cpp
 …
   LinuxKeyboard.cpp
   LinuxMouse.cpp
+COMPILATION_END
+)

code/trunk/src/external/ois/mac/CMakeLists.txt

-                      r5781
+                      r5929
   MacPrereqs.h
+COMPILATION_BEGIN OISMacCompilation.cpp
   MacHelpers.cpp
   MacHIDManager.cpp
 …
   MacKeyboard.cpp
   MacMouse.cpp
+COMPILATION_END
+)

code/trunk/src/external/ois/win32/CMakeLists.txt

-                      r5781
+                      r5929
   Win32Prereqs.h
+COMPILATION_BEGIN OISWin32Compilation.cpp
   Win32ForceFeedback.cpp
   Win32InputManager.cpp
 …
   Win32KeyBoard.cpp
   Win32Mouse.cpp
+COMPILATION_END
+)

code/trunk/src/external/ois/win32/Win32ForceFeedback.cpp

r5781	r5929
26	26
27	27	// 0 = No trace; 1 = Important traces; 2 = Debug traces
28		#define OIS_WIN32_JOYFF_DEBUG 1
	28	#define OIS_WIN32_JOYFF_DEBUG 0
29	29
30	30	#if (defined (_DEBUG) \|\| defined(OIS_WIN32_JOYFF_DEBUG))

code/trunk/src/external/tinyxml/CMakeLists.txt

-                      r5781
+                      r5929
+ #
 SET(TINYXML++_FILES
+SET_SOURCE_FILES(TINYXML++_FILES
   ticpp.h
   ticpprc.h
 …
   tinyxml.h
+COMPILATION_BEGIN TicppCompilation.cpp
   ticpp.cpp
   tinystr.cpp
 …
   tinyxmlerror.cpp
   tinyxmlparser.cpp
+COMPILATION_END
+)
-# No warnings needed from third party libraries
-REMOVE_COMPILER_FLAGS("-W3 -W4" MSVC)
-ADD_COMPILER_FLAGS("-w")
 ORXONOX_ADD_LIBRARY(tinyxml++_orxonox

code/trunk/src/external/tolua/CMakeLists.txt

-                      r5738
+                      r5929
 ################### Tolua++ library ###################
 SET(TOLUA++_FILES
+SET_SOURCE_FILES(TOLUA++_FILES
   tolua_event.h
   tolua++.h
+COMPILATION_BEGIN ToluaCompilation.c
   tolua_event.c
   tolua_is.c
 …
   tolua_push.c
   tolua_to.c
+COMPILATION_END
+)
-GENERATE_SOURCE_GROUPS(${TOLUA++_FILES})
-# No warnings needed from third party libraries
-REMOVE_COMPILER_FLAGS("-W3 -W4" MSVC)
-ADD_COMPILER_FLAGS("-w")
 ORXONOX_ADD_LIBRARY(tolua++_orxonox

code/trunk/src/libraries/CMakeLists.txt

-                      r5781
+                      r5929
 ################ Sub Directories ################
+ADD_SUBDIRECTORY(util)
 ADD_SUBDIRECTORY(core)
 ADD_SUBDIRECTORY(network)
 ADD_SUBDIRECTORY(tools)
-ADD_SUBDIRECTORY(util)

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

-                      r5781
+                      r5929
             ArgumentCompletionList classlist;
             for (std::map<std::string, Identifier*>::const_iterator it = Identifier::getIdentifierMapBegin(); it != Identifier::getIdentifierMapEnd(); ++it)
+            for (std::map<std::string, Identifier*>::const_iterator it = Identifier::getStringIdentifierMapBegin(); it != Identifier::getStringIdentifierMapEnd(); ++it)
                 if ((*it).second->hasConfigValues())
                     classlist.push_back(ArgumentCompletionListElement((*it).second->getName(), getLowercase((*it).first)));
 …
+        {
             ArgumentCompletionList configvalues;
             std::map<std::string, Identifier*>::const_iterator identifier = Identifier::getIdentifierMap().find(classname);
+            std::map<std::string, Identifier*>::const_iterator identifier = Identifier::getStringIdentifierMap().find(classname);
             if (identifier != Identifier::getIdentifierMapEnd() && (*identifier).second->hasConfigValues())
+            if (identifier != Identifier::getStringIdentifierMapEnd() && (*identifier).second->hasConfigValues())
+            {
                 for (std::map<std::string, ConfigValueContainer*>::const_iterator it = (*identifier).second->getConfigValueMapBegin(); it != (*identifier).second->getConfigValueMapEnd(); ++it)
 …
+        {
             ArgumentCompletionList oldvalue;
             std::map<std::string, Identifier*>::const_iterator identifier = Identifier::getLowercaseIdentifierMap().find(getLowercase(classname));
             if (identifier != Identifier::getLowercaseIdentifierMapEnd())
+            std::map<std::string, Identifier*>::const_iterator identifier = Identifier::getLowercaseStringIdentifierMap().find(getLowercase(classname));
+            if (identifier != Identifier::getLowercaseStringIdentifierMapEnd())
+            {
                 std::map<std::string, ConfigValueContainer*>::const_iterator variable = (*identifier).second->getLowercaseConfigValueMap().find(getLowercase(varname));

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

-                      r5781
+                      r5929
         this->bVisible_ = true;
         this->oldGametype_ = 0;
+        this->bRegisteredEventStates_ = false;
         this->lastLoadedXMLElement_ = 0;
+        this->functorSetMainState_ = 0;
+        this->functorGetMainState_ = 0;
+        this->mainStateFunctor_ = 0;
         this->setCreator(creator);
 …
             this->setFile(this->creator_->getFile());
             this->setNamespace(this->creator_->getNamespace());
             this->setScene(this->creator_->getScene());
+            this->setScene(this->creator_->getScene(), this->creator_->getSceneID());
             this->setGametype(this->creator_->getGametype());
+        }
 …
             this->namespace_ = 0;
             this->scene_ = 0;
+            this->sceneID_ = OBJECTID_UNKNOWN;
             this->gametype_ = 0;
+        }
 …
         if (this->isInitialized())
+        {
+            for (std::list<BaseObject*>::const_iterator it = this->events_.begin(); it != this->events_.end(); ++it)
+                (*it)->unregisterEventListener(this);
+            for (std::map<BaseObject*, std::string>::const_iterator it = this->eventListeners_.begin(); it != this->eventListeners_.end(); ++it)
+                it->first->removeEvent(this);
+            if (this->functorSetMainState_)
+                delete this->functorSetMainState_;
+            if (this->functorGetMainState_)
+                delete this->functorGetMainState_;
+            for (std::map<BaseObject*, std::string>::const_iterator it = this->eventSources_.begin(); it != this->eventSources_.end(); )
+                this->removeEventSource((it++)->first);
+            for (std::set<BaseObject*>::const_iterator it = this->eventListeners_.begin(); it != this->eventListeners_.end(); )
+                (*(it++))->removeEventSource(this);
+            for (std::map<std::string, EventState*>::const_iterator it = this->eventStates_.begin(); it != this->eventStates_.end(); ++it)
+                delete it->second;
+        }
+    }
 …
         @param xmlelement The XML-element
         @param loading Loading (true) or saving (false)
-        @return The XML-element
     */
     void BaseObject::XMLPort(Element& xmlelement, XMLPort::Mode mode)
 …
         XMLPortObjectTemplate(BaseObject, Template, "templates", addTemplate, getTemplate, xmlelement, mode, Template*);
+        Element* events = xmlelement.FirstChildElement("events", false);
+        XMLPortObject(BaseObject, BaseObject, "eventlisteners", addEventListener, getEventListener, xmlelement, mode);
+        Element* events = 0;
+        if (mode == XMLPort::LoadObject || mode == XMLPort::ExpandObject)
+            events = xmlelement.FirstChildElement("events", false);
+        else if (mode == XMLPort::SaveObject)
+            {}
         if (events)
+        {
+            std::list<std::string> eventnames;
+            if (mode == XMLPort::LoadObject || mode == XMLPort::ExpandObject)
+            {
+                for (ticpp::Iterator<ticpp::Element> child = events->FirstChildElement(false); child != child.end(); child++)
+                    eventnames.push_back(child->Value());
+            }
+            else if (mode == XMLPort::SaveObject)
+            {
+                for (std::map<std::string, XMLPortObjectContainer*>::const_iterator it = this->getIdentifier()->getXMLPortEventMapBegin(); it != this->getIdentifier()->getXMLPortEventMapEnd(); ++it)
+                    eventnames.push_back(it->first);
+            }
+            for (std::list<std::string>::iterator it = eventnames.begin(); it != eventnames.end(); ++it)
+            {
+                std::string sectionname = (*it);
+                ExecutorMember<BaseObject>* loadexecutor = createExecutor(createFunctor(&BaseObject::addEvent), std::string( "BaseObject" ) + "::" + "addEvent");
+                ExecutorMember<BaseObject>* saveexecutor = createExecutor(createFunctor(&BaseObject::getEvent), std::string( "BaseObject" ) + "::" + "getEvent");
+                loadexecutor->setDefaultValue(1, sectionname);
+                XMLPortClassObjectContainer<BaseObject, BaseObject>* container = 0;
+                container = (XMLPortClassObjectContainer<BaseObject, BaseObject>*)(this->getIdentifier()->getXMLPortEventContainer(sectionname));
+                if (!container)
+                {
+                    container = new XMLPortClassObjectContainer<BaseObject, BaseObject>(sectionname, this->getIdentifier(), loadexecutor, saveexecutor, false, true);
+                    this->getIdentifier()->addXMLPortEventContainer(sectionname, container);
+                }
+                container->port(this, *events, mode);
+            }
+        }
+            this->XMLEventPort(*events, mode);
+    }
+    /**
+        @brief Defines the possible event states of this object and parses eventsources from an XML file.
+        @param xmlelement The XML-element
+        @param loading Loading (true) or saving (false)
+    */
+    void BaseObject::XMLEventPort(Element& xmlelement, XMLPort::Mode mode)
+    {
+        XMLPortEventState(BaseObject, BaseObject, "activity", setActive, xmlelement, mode);
+        XMLPortEventState(BaseObject, BaseObject, "visibility", setVisible, xmlelement, mode);
+        XMLPortEventState(BaseObject, BaseObject, "mainstate", setMainState, xmlelement, mode);
+        this->bRegisteredEventStates_ = true;
+    }
 …
+    }
+    void BaseObject::addEvent(BaseObject* event, const std::string& sectionname)
+    {
+        event->registerEventListener(this, sectionname);
+        this->events_.push_back(event);
+    }
+    void BaseObject::removeEvent(BaseObject* event)
+    {
+        this->events_.remove(event);
+    }
+    BaseObject* BaseObject::getEvent(unsigned int index) const
+    /**
+        @brief Adds a new event source for a specific state.
+        @param source The object which sends events to this object
+        @param state The state of this object which will be affected by the events
+    */
+    void BaseObject::addEventSource(BaseObject* source, const std::string& state)
+    {
+        this->eventSources_[source] = state;
+        source->registerEventListener(this);
+    }
+    /**
+        @brief Removes an eventsource (but doesn't unregister itself at the source).
+    */
+    void BaseObject::removeEventSource(BaseObject* source)
+    {
+        this->eventSources_.erase(source);
+        source->unregisterEventListener(this);
+    }
+    /**
+        @brief Returns an eventsource with a given index.
+    */
+    BaseObject* BaseObject::getEventSource(unsigned int index, const std::string& state) const
+    {
         unsigned int i = 0;
+        for (std::list<BaseObject*>::const_iterator it = this->events_.begin(); it != this->events_.end(); ++it)
+        {
+        for (std::map<BaseObject*, std::string>::const_iterator it = this->eventSources_.begin(); it != this->eventSources_.end(); ++it)
+        {
+            if (it->second != state)
+                continue;
             if (i == index)
                 return (*it);
+                return it->first;
             ++i;
+        }
 …
+    }
+    void BaseObject::addEventContainer(const std::string& sectionname, EventContainer* container)
+    {
+        std::map<std::string, EventContainer*>::const_iterator it = this->eventContainers_.find(sectionname);
+        if (it != this->eventContainers_.end())
+        {
+            COUT(2) << "Warning: Overwriting EventContainer in class " << this->getIdentifier()->getName() << "." << std::endl;
+    /**
+        @brief Adds an object which listens to the events of this object. The events are sent to the other objects mainstate.
+    */
+    void BaseObject::addEventListener(BaseObject* listener)
+    {
+        this->eventListenersXML_.insert(listener);
+        listener->addEventSource(this, "mainstate");
+    }
+    /**
+        @brief Returns an event listener with a given index.
+    */
+    BaseObject* BaseObject::getEventListener(unsigned int index) const
+    {
+        unsigned int i = 0;
+        for (std::set<BaseObject*>::const_iterator it = this->eventListenersXML_.begin(); it != this->eventListenersXML_.end(); ++it)
+        {
+            if (i == index)
+                return *it;
+            ++i;
+        }
+        return 0;
+    }
+    /**
+        @brief Adds a new event-state to the object. Event-states are states which can be changed by events.
+        @param name  The name of the event
+        @param state The object containing information about the event-state
+    */
+    void BaseObject::addEventState(const std::string& name, EventState* state)
+    {
+        std::map<std::string, EventState*>::const_iterator it = this->eventStates_.find(name);
+        if (it != this->eventStates_.end())
+        {
+            COUT(2) << "Warning: Overwriting EventState in class " << this->getIdentifier()->getName() << "." << std::endl;
             delete (it->second);
+        }
+        this->eventContainers_[sectionname] = container;
+    }
+    EventContainer* BaseObject::getEventContainer(const std::string& sectionname) const
+    {
+        std::map<std::string, EventContainer*>::const_iterator it = this->eventContainers_.find(sectionname);
+        if (it != this->eventContainers_.end())
+        this->eventStates_[name] = state;
+    }
+    /**
+        @brief Returns the event-state with the given name.
+    */
+    EventState* BaseObject::getEventState(const std::string& name) const
+    {
+        std::map<std::string, EventState*>::const_iterator it = this->eventStates_.find(name);
+        if (it != this->eventStates_.end())
             return ((*it).second);
         else
 …
+    }
+    void BaseObject::fireEvent()
+    {
+        this->fireEvent(true);
+        this->fireEvent(false);
+    }
+    void BaseObject::fireEvent(bool activate)
+    {
+        this->fireEvent(activate, this);
+    }
+    void BaseObject::fireEvent(bool activate, BaseObject* originator)
+    {
+        Event event(activate, originator);
+        for (std::map<BaseObject*, std::string>::iterator it = this->eventListeners_.begin(); it != this->eventListeners_.end(); ++it)
+        {
+            event.sectionname_ = it->second;
+            it->first->processEvent(event);
+        }
+    }
+    /**
+        @brief Fires an event (without a state).
+    */
+    void BaseObject::fireEvent(const std::string& name)
+    {
+        this->fireEvent(true, name);
+        this->fireEvent(false, name);
+    }
+    /**
+        @brief Fires an event which activates or deactivates a state.
+    */
+    void BaseObject::fireEvent(bool activate, const std::string& name)
+    {
+        this->fireEvent(activate, this, name);
+    }
+    /**
+        @brief Fires an event which activates or deactivates a state with agiven originator (the object which triggered the event).
+    */
+    void BaseObject::fireEvent(bool activate, BaseObject* originator, const std::string& name)
+    {
+        Event event(activate, originator, name);
+        for (std::set<BaseObject*>::iterator it = this->eventListeners_.begin(); it != this->eventListeners_.end(); ++it)
+        {
+            event.statename_ = (*it)->eventSources_[this];
+            (*it)->processEvent(event);
+        }
+    }
+    /**
+        @brief Fires an event, using the Event struct.
+    */
     void BaseObject::fireEvent(Event& event)
+    {
+        for (std::map<BaseObject*, std::string>::iterator it = this->eventListeners_.begin(); it != this->eventListeners_.end(); ++it)
+            it->first->processEvent(event);
+    }
+        for (std::set<BaseObject*>::iterator it = this->eventListeners_.begin(); it != this->eventListeners_.end(); ++it)
+            (*it)->processEvent(event);
+    }
+    /**
+        @brief Processing an event by calling the right main state.
+        @param event The event struct which contains the information about the event
+    */
     void BaseObject::processEvent(Event& event)
+    {
+        ORXONOX_SET_EVENT(BaseObject, "activity", setActive, event);
+        ORXONOX_SET_EVENT(BaseObject, "visibility", setVisible, event);
+    }
+    void BaseObject::setMainStateName(const std::string& name)
+    {
+        if (this->mainStateName_ != name)
+        {
+            this->mainStateName_ = name;
+            if (this->functorSetMainState_)
+                delete this->functorSetMainState_;
+            if (this->functorGetMainState_)
+                delete this->functorGetMainState_;
+            this->changedMainState();
+            if (!this->functorSetMainState_)
+                COUT(2) << "Warning: \"" << name << "\" is not a valid MainState." << std::endl;
+        }
+    }
+        this->registerEventStates();
+        std::map<std::string, EventState*>::const_iterator it = this->eventStates_.find(event.statename_);
+        if (it != this->eventStates_.end())
+            it->second->process(event, this);
+        else if (event.statename_ != "")
+            COUT(2) << "Warning: \"" << event.statename_ << "\" is not a valid state in object \"" << this->getName() << "\" of class " << this->getIdentifier()->getName() << "." << std::endl;
+        else
+            COUT(2) << "Warning: Event with invalid source sent to object \"" << this->getName() << "\" of class " << this->getIdentifier()->getName() << "." << std::endl;
+    }
+    /**
+        @brief Sets the main state of the object to a given boolean value.
+        Note: The main state of an object can be set with the @ref setMainStateName function.
+        It's part of the eventsystem and used for event forwarding (when the target object can't specify a specific state,
+        the main state is used by default).
+    */
     void BaseObject::setMainState(bool state)
+    {
+        if (this->functorSetMainState_)
+            (*this->functorSetMainState_)(state);
+        if (this->mainStateFunctor_)
+        {
+            if (this->mainStateFunctor_->getParamCount() == 0)
+            {
+                if (state)
+                    (*this->mainStateFunctor_)();
+            }
+            else
+            {
+                (*this->mainStateFunctor_)(state);
+            }
+        }
         else
             COUT(2) << "Warning: No MainState defined in object \"" << this->getName() << "\" (" << this->getIdentifier()->getName() << ")" << std::endl;
+    }
+    bool BaseObject::getMainState() const
+    {
+        if (this->functorGetMainState_)
+        {
+            (*this->functorGetMainState_)();
+            return this->functorGetMainState_->getReturnvalue();
+        }
+        else
+        {
+            COUT(2) << "Warning: No MainState defined in object \"" << this->getName() << "\" (" << this->getIdentifier()->getName() << ")" << std::endl;
+            return false;
+        }
+    }
+    void BaseObject::changedMainState()
+    {
+        SetMainState(BaseObject, "activity",   setActive,  isActive);
+        SetMainState(BaseObject, "visibility", setVisible, isVisible);
+    /**
+        @brief This function gets called if the main state name of the object changes.
+    */
+    void BaseObject::changedMainStateName()
+    {
+        this->mainStateFunctor_ = 0;
+        if (this->mainStateName_ != "")
+        {
+            this->registerEventStates();
+            std::map<std::string, EventState*>::const_iterator it = this->eventStates_.find(this->mainStateName_);
+            if (it != this->eventStates_.end() && it->second->getFunctor())
+            {
+                if (it->second->getFunctor()->getParamCount() <= 1)
+                    this->mainStateFunctor_ = it->second->getFunctor();
+                else
+                    COUT(2) << "Warning: Can't use \"" << this->mainStateName_ << "\" as MainState because it needs a second argument." << std::endl;
+            }
+            else
+                COUT(2) << "Warning: \"" << this->mainStateName_ << "\" is not a valid MainState." << std::endl;
+        }
+    }
+    /**
+        @brief Calls XMLEventPort with an empty XML-element to register the event states if necessary.
+    */
+    void BaseObject::registerEventStates()
+    {
+        if (!this->bRegisteredEventStates_)
+        {
+            Element xmlelement;
+            this->XMLEventPort(xmlelement, XMLPort::NOP);
+        }
+    }
+    /**
+        @brief Manually loads all event states, even if the class doesn't officially support them. This is needed by some classes like @ref EventDispatcher or @ref EventTarget.
+    */
+    void BaseObject::loadAllEventStates(Element& xmlelement, XMLPort::Mode mode, BaseObject* object, Identifier* identifier)
+    {
+        Element* events = xmlelement.FirstChildElement("events", false);
+        if (events)
+        {
+            // get the list of all states present
+            std::list<std::string> eventnames;
+            if (mode == XMLPort::LoadObject || mode == XMLPort::ExpandObject)
+            {
+                for (ticpp::Iterator<ticpp::Element> child = events->FirstChildElement(false); child != child.end(); child++)
+                    eventnames.push_back(child->Value());
+            }
+            else if (mode == XMLPort::SaveObject)
+            {
+            }
+            // iterate through all states and get the event sources
+            for (std::list<std::string>::iterator it = eventnames.begin(); it != eventnames.end(); ++it)
+            {
+                std::string statename = (*it);
+                // if the event state is already known, continue with the next state
+                orxonox::EventState* eventstate = object->getEventState(statename);
+                if (eventstate)
+                    continue;
+                XMLPortClassObjectContainer<BaseObject, BaseObject>* container = (XMLPortClassObjectContainer<BaseObject, BaseObject>*)(identifier->getXMLPortObjectContainer(statename));
+                if (!container)
+                {
+                    ExecutorMember<BaseObject>* setfunctor = createExecutor(createFunctor(&BaseObject::addEventSource), std::string( "BaseObject" ) + "::" + "addEventSource" + "(" + statename + ")");
+                    ExecutorMember<BaseObject>* getfunctor = createExecutor(createFunctor(&BaseObject::getEventSource), std::string( "BaseObject" ) + "::" + "getEventSource" + "(" + statename + ")");
+                    setfunctor->setDefaultValue(1, statename);
+                    getfunctor->setDefaultValue(1, statename);
+                    container = new XMLPortClassObjectContainer<BaseObject, BaseObject>(statename, identifier, setfunctor, getfunctor, false, true);
+                    identifier->addXMLPortObjectContainer(statename, container);
+                }
+                container->port(object, *events, mode);
+            }
+        }
+    }
+}

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

-                      r5781
+                      r5929
 #define _BaseObject_H__
-#define SetMainState(classname, statename, setfunction, getfunction) \
-    if (this->getMainStateName() == statename) \
-    { \
-        this->functorSetMainState_ = createFunctor(&classname::setfunction)->setObject(this); \
-        this->functorGetMainState_ = createFunctor(&classname::getfunction)->setObject(this); \
+    }
 #include "CorePrereqs.h"
 …
 #include "OrxonoxClass.h"
 #include "Super.h"
+#include "SmartPtr.h"
 namespace orxonox
 …
             virtual ~BaseObject();
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void XMLEventPort(Element& xmlelement, XMLPort::Mode mode);
             /** @brief Returns if the object was initialized (passed the object registration). @return True was the object is initialized */
 …
             void setMainState(bool state);
+            bool getMainState() const;
+            void setMainStateName(const std::string& name);
+            /** @brief Sets the name of the main state (used for event reactions). */
+            void setMainStateName(const std::string& name)
+            {
+                if (this->mainStateName_ != name)
+                {
+                    this->mainStateName_ = name;
+                    this->changedMainStateName();
+                }
+            }
+            /** @brief Returns the name of the main state. */
             inline const std::string& getMainStateName() const { return this->mainStateName_; }
+            virtual void changedMainState();
+            /** @brief This function gets called if the main state name of the object changes. */
+            virtual void changedMainStateName();
             /** @brief Sets a pointer to the xml file that loaded this object. @param file The pointer to the XMLFile */
 …
             inline BaseObject* getCreator() const { return this->creator_; }
+            inline void setScene(Scene* scene) { this->scene_ = scene; }
+            inline Scene* getScene() const { return this->scene_; }
+            inline void setGametype(Gametype* gametype)
+            inline void setScene(const SmartPtr<Scene>& scene, uint32_t sceneID) { this->scene_ = scene; this->sceneID_=sceneID; }
+            inline const SmartPtr<Scene>& getScene() const { return this->scene_; }
+            inline virtual uint32_t getSceneID() const { return this->sceneID_; }
+            inline void setGametype(const SmartPtr<Gametype>& gametype)
+            {
                 if (gametype != this->gametype_)
 …
+                }
+            }
             inline Gametype* getGametype() const { return this->gametype_; }
+            inline const SmartPtr<Gametype>& getGametype() const { return this->gametype_; }
             inline Gametype* getOldGametype() const { return this->oldGametype_; }
             virtual void changedGametype() {}
+            void fireEvent();
+            void fireEvent(bool activate);
+            void fireEvent(bool activate, BaseObject* originator);
+            void addEventSource(BaseObject* source, const std::string& state);
+            void removeEventSource(BaseObject* source);
+            BaseObject* getEventSource(unsigned int index, const std::string& state) const;
+            void addEventListener(BaseObject* listener);
+            BaseObject* getEventListener(unsigned int index) const;
+            void fireEvent(const std::string& name = "");
+            void fireEvent(bool activate, const std::string& name = "");
+            void fireEvent(bool activate, BaseObject* originator, const std::string& name = "");
             void fireEvent(Event& event);
             virtual void processEvent(Event& event);
-            inline void registerEventListener(BaseObject* object, const std::string& sectionname)
-                { this->eventListeners_[object] = sectionname; }
-            inline void unregisterEventListener(BaseObject* object)
-                { this->eventListeners_.erase(object); }
-            void addEvent(BaseObject* event, const std::string& sectionname);
-            void removeEvent(BaseObject* event);
-            BaseObject* getEvent(unsigned int index) const;
-            void addEventContainer(const std::string& sectionname, EventContainer* container);
-            EventContainer* getEventContainer(const std::string& sectionname) const;
             /** @brief Sets the indentation of the debug output in the Loader. @param indentation The indentation */
 …
             /** @brief Returns the indentation of the debug output in the Loader. @return The indentation */
             inline const std::string& getLoaderIndentation() const { return this->loaderIndentation_; }
+            static void loadAllEventStates(Element& xmlelement, XMLPort::Mode mode, BaseObject* object, Identifier* identifier);
         protected:
+            void addEventState(const std::string& name, EventState* container);
+            EventState* getEventState(const std::string& name) const;
             std::string name_;                                 //!< The name of the object
             std::string oldName_;                              //!< The old name of the object
 …
             mbool       bVisible_;                             //!< True = the object is visible
             std::string mainStateName_;
+            Functor*    functorSetMainState_;
+            Functor*    functorGetMainState_;
+            Functor*    mainStateFunctor_;
         private:
+            /** @brief Adds an object which listens to the events of this object. */
+            inline void registerEventListener(BaseObject* object)
+                { this->eventListeners_.insert(object); }
+            /** @brief Removes an event listener from this object. */
+            inline void unregisterEventListener(BaseObject* object)
+                { this->eventListeners_.erase(object); }
             void setXMLName(const std::string& name);
             Template* getTemplate(unsigned int index) const;
+            void registerEventStates();
             bool                   bInitialized_;              //!< True if the object was initialized (passed the object registration)
 …
             Namespace*             namespace_;
             BaseObject*            creator_;
+            Scene*                 scene_;
+            Gametype*              gametype_;
+            SmartPtr<Scene>        scene_;
+            uint32_t               sceneID_;
+            SmartPtr<Gametype>     gametype_;
             Gametype*              oldGametype_;
             std::set<Template*>    templates_;
+            std::map<BaseObject*,  std::string> eventListeners_;
+            std::list<BaseObject*> events_;
+            std::map<std::string, EventContainer*> eventContainers_;
+            std::map<BaseObject*, std::string>  eventSources_;           //!< List of objects which send events to this object, mapped to the state which they affect
+            std::set<BaseObject*>               eventListeners_;         //!< List of objects which listen to the events of this object
+            std::set<BaseObject*>               eventListenersXML_;      //!< List of objects which listen to the events of this object through the "eventlisteners" subsection in XML
+            std::map<std::string, EventState*>  eventStates_;            //!< Maps the name of the event states to their helper objects
+            bool                                bRegisteredEventStates_; //!< Becomes true after the object registered its event states (with XMLEventPort)
     };
 …
     SUPER_FUNCTION(2, BaseObject, changedActivity, false);
     SUPER_FUNCTION(3, BaseObject, changedVisibility, false);
+    SUPER_FUNCTION(4, BaseObject, processEvent, false);
+    SUPER_FUNCTION(6, BaseObject, changedMainState, false);
+    SUPER_FUNCTION(9, BaseObject, changedName, false);
+    SUPER_FUNCTION(10, BaseObject, changedGametype, false);
+    SUPER_FUNCTION(4, BaseObject, XMLEventPort, false);
+    SUPER_FUNCTION(8, BaseObject, changedName, false);
+    SUPER_FUNCTION(9, BaseObject, changedGametype, false);
+}

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

-                      r5781
+                      r5929
 SET_SOURCE_FILES(CORE_SRC_FILES
-  Clock.cc
-  ConfigFileManager.cc
   ConfigValueContainer.cc
   Core.cc
 …
   Language.cc
   LuaState.cc
-  MemoryArchive.cc
   ObjectListBase.cc
   OrxonoxClass.cc
   Resource.cc
+  ScopedSingletonManager.cc
   WindowEventListener.cc
   # command
-  ArgumentCompletionFunctions.cc
   CommandEvaluation.cc
   CommandExecutor.cc
 …
   # hierarchy
-  Factory.cc
   Identifier.cc
   MetaObjectList.cc
 …
   Shell.cc
   TclBind.cc
+COMPILATION_BEGIN FilesystemCompilation.cc
+  ArgumentCompletionFunctions.cc
+  ConfigFileManager.cc
+  MemoryArchive.cc
+  PathConfig.cc
+COMPILATION_END
+  # multithreading
+  ThreadPool.cc
+COMPILATION_BEGIN ThreadCompilation.cc
   TclThreadManager.cc
-  # multithreading
   Thread.cc
+  ThreadPool.cc
+COMPILATION_END
+)
 ADD_SUBDIRECTORY(input)

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

-                      r5781
+                      r5929
 #include "util/Debug.h"
-#include "Factory.h"
 #include "Identifier.h"
 namespace orxonox
+{
+    // ###########################
+    // ###       Factory       ###
+    // ###########################
+    //! Base-class of ClassFactory.
+    class _CoreExport Factory
+    {
+        public:
+            virtual ~Factory() {};
+            virtual BaseObject* fabricate(BaseObject* creator) = 0;
+    };
     // ###############################
     // ###      ClassFactory       ###
 …
     //! The ClassFactory is able to create new objects of a specific class.
     template <class T>
     class ClassFactory : public BaseFactory
+    class ClassFactory : public Factory
+    {
         public:
+            static bool create(const std::string& name, bool bLoadable = true);
+            BaseObject* fabricate(BaseObject* creator);
+            /**
+                @brief Constructor: Adds the ClassFactory to the Identifier of the same type.
+                @param name The name of the class
+                @param bLoadable True if the class can be loaded through XML
+            */
+            ClassFactory(const std::string& name, bool bLoadable = true)
+            {
+                COUT(4) << "*** ClassFactory: Create entry for " << name << " in Factory." << std::endl;
+                ClassIdentifier<T>::getIdentifier(name)->addFactory(this);
+                ClassIdentifier<T>::getIdentifier()->setLoadable(bLoadable);
+            }
+        private:
+            ClassFactory() {}                               // Don't create
+            ClassFactory(const ClassFactory& factory) {}    // Don't copy
+            virtual ~ClassFactory() {}                      // Don't delete
+            static T* createNewObject(BaseObject* creator);
+            /**
+                @brief Creates and returns a new object of class T.
+                @return The new object
+            */
+            inline BaseObject* fabricate(BaseObject* creator)
+            {
+                return static_cast<BaseObject*>(new T(creator));
+            }
     };
-    /**
-        @brief Adds the ClassFactory to the Identifier of the same type and the Identifier to the Factory.
-        @param name The name of the class
-        @param bLoadable True if the class can be loaded through XML
-        @return Always true (this is needed because the compiler only allows assignments before main())
-    */
-    template <class T>
-    bool ClassFactory<T>::create(const std::string& name, bool bLoadable)
+    {
-        COUT(4) << "*** ClassFactory: Create entry for " << name << " in Factory." << std::endl;
-        ClassIdentifier<T>::getIdentifier(name)->addFactory(new ClassFactory<T>);
-        ClassIdentifier<T>::getIdentifier()->setLoadable(bLoadable);
-        Factory::add(name, ClassIdentifier<T>::getIdentifier());
-        return true;
+    }
-    /**
-        @brief Creates and returns a new object of class T.
-        @return The new object
-    */
-    template <class T>
-    inline BaseObject* ClassFactory<T>::fabricate(BaseObject* creator)
+    {
-        return ClassFactory<T>::createNewObject(creator);
+    }
-    /**
-        @brief Creates and returns a new object of class T; this is a wrapper for the new operator.
-        @return The new object
-    */
-    template <class T>
-    inline T* ClassFactory<T>::createNewObject(BaseObject* creator)
+    {
-        return new T(creator);
+    }
+}

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

r5781	r5929
488	488
489	489	// Remove the redundant subnode from the current node
	490	delete (*it);
490	491	node->subnodes_.erase(it++);
491	492	}

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

-                      r5781
+                      r5929
             /** @brief Returns true if the ClassTreeMaskObjectIterator points at the given object. @param pointer The pointer of the object */
             inline bool operator==(BaseObject* pointer) const { return ((*this->objectIterator_) == pointer); }
+            inline bool operator==(BaseObject* pointer) const { return (this->objectIterator_ && (*this->objectIterator_) == pointer) || (!this->objectIterator_ && pointer == 0); }
             /** @brief Returns true if the ClassTreeMaskObjectIterator doesn't point at the given object. @param pointer The pointer of the object */
             inline bool operator!=(BaseObject* pointer) const { return ((*this->objectIterator_) != pointer); }
+            inline bool operator!=(BaseObject* pointer) const { return (this->objectIterator_ && (*this->objectIterator_) != pointer) || (!this->objectIterator_ && pointer != 0); }
             /** @brief Returns true if the ClassTreeMaskObjectIterator hasn't already reached the end. */
             inline operator bool() const { return (this->objectIterator_); }

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

-                      r5781
+                      r5929
         CommandExecutor::getEvaluation().listOfPossibleIdentifiers_.clear();
         std::string lowercase = getLowercase(fragment);
         for (std::map<std::string, Identifier*>::const_iterator it = Identifier::getLowercaseIdentifierMapBegin(); it != Identifier::getLowercaseIdentifierMapEnd(); ++it)
+        for (std::map<std::string, Identifier*>::const_iterator it = Identifier::getLowercaseStringIdentifierMapBegin(); it != Identifier::getLowercaseStringIdentifierMapEnd(); ++it)
             if ((*it).second->hasConsoleCommands())
                 if ((*it).first.find(lowercase) == 0 || fragment == "")
 …
+    {
         std::string lowercase = getLowercase(name);
         std::map<std::string, Identifier*>::const_iterator it = Identifier::getLowercaseIdentifierMap().find(lowercase);
         if ((it != Identifier::getLowercaseIdentifierMapEnd()) && (*it).second->hasConsoleCommands())
+        std::map<std::string, Identifier*>::const_iterator it = Identifier::getLowercaseStringIdentifierMap().find(lowercase);
+        if ((it != Identifier::getLowercaseStringIdentifierMapEnd()) && (*it).second->hasConsoleCommands())
             return (*it).second;

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

-                      r5738
+                      r5929
 #include <algorithm>
 #include <sstream>
-#include <boost/filesystem.hpp>
 #include "util/Convert.h"
 …
 #include "util/StringUtils.h"
 #include "util/SubString.h"
 #include "Core.h"
+#include "PathConfig.h"
 namespace orxonox
 …
+        }
+        infoStr << std::endl;
         infoStr << "Usage: orxonox [options]" << std::endl;
         infoStr << "Available options:" << std::endl;
 …
+    {
         std::string filename = CommandLine::getValue("optionsFile").getString();
-        boost::filesystem::path filepath(Core::getConfigPath() / filename);
         // look for additional arguments in given file or start.ini as default
         // They will not overwrite the arguments given directly
         std::ifstream file;
         file.open(filepath.string().c_str());
+        file.open((PathConfig::getConfigPathString() + filename).c_str());
         std::vector<std::string> args;
         if (file)

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

-                      r5781
+                      r5929
 #include "ConsoleCommand.h"
 #include "ConfigValueContainer.h"
 #include "Core.h"
+#include "PathConfig.h"
 namespace orxonox
 …
     bool config(const std::string& classname, const std::string& varname, const std::string& value)
+    {
         std::map<std::string, Identifier*>::const_iterator identifier = Identifier::getLowercaseIdentifierMap().find(getLowercase(classname));
         if (identifier != Identifier::getLowercaseIdentifierMapEnd())
+        std::map<std::string, Identifier*>::const_iterator identifier = Identifier::getLowercaseStringIdentifierMap().find(getLowercase(classname));
+        if (identifier != Identifier::getLowercaseStringIdentifierMapEnd())
+        {
             std::map<std::string, ConfigValueContainer*>::const_iterator variable = (*identifier).second->getLowercaseConfigValueMap().find(getLowercase(varname));
 …
     bool tconfig(const std::string& classname, const std::string& varname, const std::string& value)
+    {
         std::map<std::string, Identifier*>::const_iterator identifier = Identifier::getLowercaseIdentifierMap().find(getLowercase(classname));
         if (identifier != Identifier::getLowercaseIdentifierMapEnd())
+        std::map<std::string, Identifier*>::const_iterator identifier = Identifier::getLowercaseStringIdentifierMap().find(getLowercase(classname));
+        if (identifier != Identifier::getLowercaseStringIdentifierMapEnd())
+        {
             std::map<std::string, ConfigValueContainer*>::const_iterator variable = (*identifier).second->getLowercaseConfigValueMap().find(getLowercase(varname));
 …
         // Get default file if necessary and available
         boost::filesystem::path filepath(Core::getConfigPath() / this->filename_);
+        boost::filesystem::path filepath(PathConfig::getConfigPath() / this->filename_);
         if (!boost::filesystem::exists(filepath))
+        {
             // Try to get default one from the data folder
             boost::filesystem::path defaultFilepath(Core::getDataPath() / "defaultConfig" / this->filename_);
+            boost::filesystem::path defaultFilepath(PathConfig::getDataPath() / "defaultConfig" / this->filename_);
             if (boost::filesystem::exists(defaultFilepath))
+            {
 …
+    {
         std::ofstream file;
         file.open((Core::getConfigPathString() + filename_).c_str(), std::fstream::out);
+        file.open((PathConfig::getConfigPathString() + filename_).c_str(), std::fstream::out);
         file.setf(std::ios::fixed, std::ios::floatfield);
         file.precision(6);
 …
         for (std::list<ConfigFileSection*>::iterator it1 = this->sections_.begin(); it1 != this->sections_.end(); )
+        {
             std::map<std::string, Identifier*>::const_iterator it2 = Identifier::getIdentifierMap().find((*it1)->getName());
             if (it2 != Identifier::getIdentifierMapEnd() && (*it2).second->hasConfigValues())
+            std::map<std::string, Identifier*>::const_iterator it2 = Identifier::getStringIdentifierMap().find((*it1)->getName());
+            if (it2 != Identifier::getStringIdentifierMapEnd() && (*it2).second->hasConfigValues())
+            {
                 // The section exists, delete comment
 …
         if (this->type_ == ConfigFileType::Settings)
+        {
             for (std::map<std::string, Identifier*>::const_iterator it = Identifier::getIdentifierMapBegin(); it != Identifier::getIdentifierMapEnd(); ++it)
+            for (std::map<std::string, Identifier*>::const_iterator it = Identifier::getStringIdentifierMapBegin(); it != Identifier::getStringIdentifierMapEnd(); ++it)
+            {
                 if (it->second->hasConfigValues())

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

-                      r5781
+                      r5929
 #include <cassert>
+#include <fstream>
+#include <cstdlib>
+#include <cstdio>
+#include <boost/version.hpp>
+#include <boost/filesystem.hpp>
+#include <vector>
 #ifdef ORXONOX_PLATFORM_WINDOWS
 …
 #  undef min
 #  undef max
-#elif defined(ORXONOX_PLATFORM_APPLE)
-#  include <sys/param.h>
-#  include <mach-o/dyld.h>
-#else /* Linux */
-#  include <sys/types.h>
-#  include <unistd.h>
 #endif
 #include "SpecialConfig.h"
+#include "util/Clock.h"
 #include "util/Debug.h"
 #include "util/Exception.h"
 #include "util/SignalHandler.h"
 #include "Clock.h"
+#include "PathConfig.h"
 #include "CommandExecutor.h"
 #include "CommandLine.h"
 …
 #include "CoreIncludes.h"
 #include "DynLibManager.h"
-#include "Factory.h"
 #include "GameMode.h"
 #include "GraphicsManager.h"
 …
 #include "Language.h"
 #include "LuaState.h"
+#include "ScopedSingletonManager.h"
 #include "Shell.h"
 #include "TclBind.h"
 …
 #include "input/InputManager.h"
-// Boost 1.36 has some issues with deprecated functions that have been omitted
-#if (BOOST_VERSION == 103600)
-#  define BOOST_LEAF_FUNCTION filename
-#else
-#  define BOOST_LEAF_FUNCTION leaf
-#endif
 namespace orxonox
+{
 …
     Core* Core::singletonPtr_s  = 0;
-    SetCommandLineArgument(externalDataPath, "").information("Path to the external data files");
-    SetCommandLineOnlyArgument(writingPathSuffix, "").information("Additional subfolder for config and log files");
     SetCommandLineArgument(settingsFile, "orxonox.ini").information("THE configuration file");
 #ifdef ORXONOX_PLATFORM_WINDOWS
 …
             RegisterRootObject(CoreConfiguration);
             this->setConfigValues();
-            // External data directory only exists for dev runs
-            if (Core::isDevelopmentRun())
+            {
-                // Possible data path override by the command line
-                if (!CommandLine::getArgument("externalDataPath")->hasDefaultValue())
-                    tsetExternalDataPath(CommandLine::getValue("externalDataPath"));
+            }
+        }
 …
+        }
-        /**
-        @brief
-            Temporary sets the external data path
-        @param path
-            The new data path
-        */
-        void tsetExternalDataPath(const std::string& path)
+        {
-            externalDataPath_ = boost::filesystem::path(path);
+        }
         void initializeRandomNumberGenerator()
+        {
 …
         std::string language_;                          //!< The language
         bool bInitializeRandomNumberGenerator_;         //!< If true, srand(time(0)) is called
-        //! Path to the parent directory of the ones above if program was installed with relativ pahts
-        boost::filesystem::path rootPath_;
-        boost::filesystem::path executablePath_;        //!< Path to the executable
-        boost::filesystem::path modulePath_;            //!< Path to the modules
-        boost::filesystem::path dataPath_;              //!< Path to the data file folder
-        boost::filesystem::path externalDataPath_;      //!< Path to the external data file folder
-        boost::filesystem::path configPath_;            //!< Path to the config file folder
-        boost::filesystem::path logPath_;               //!< Path to the log file folder
     };
 …
         , consoleCommandDestroyer_(CommandExecutor::destroyExternalCommands)
         , configuration_(new CoreConfiguration()) // Don't yet create config values!
-        , bDevRun_(false)
         , bGraphicsLoaded_(false)
+    {
         // Set the hard coded fixed paths
         this->setFixedPaths();
+        this->pathConfig_.reset(new PathConfig());
         // Create a new dynamic library manager
 …
         // Load modules
+        try
+        {
+            // We search for helper files with the following extension
+            std::string moduleextension = specialConfig::moduleExtension;
+            size_t moduleextensionlength = moduleextension.size();
+            // Search in the directory of our executable
+            boost::filesystem::path searchpath = this->configuration_->modulePath_;
+            // Add that path to the PATH variable in case a module depends on another one
+            std::string pathVariable = getenv("PATH");
+            putenv(const_cast<char*>(("PATH=" + pathVariable + ";" + configuration_->modulePath_.string()).c_str()));
+            boost::filesystem::directory_iterator file(searchpath);
+            boost::filesystem::directory_iterator end;
+            // Iterate through all files
+            while (file != end)
+        const std::vector<std::string>& modulePaths = this->pathConfig_->getModulePaths();
+        for (std::vector<std::string>::const_iterator it = modulePaths.begin(); it != modulePaths.end(); ++it)
+        {
+            try
+            {
+                std::string filename = file->BOOST_LEAF_FUNCTION();
+                // Check if the file ends with the exension in question
+                if (filename.size() > moduleextensionlength)
+                {
+                    if (filename.substr(filename.size() - moduleextensionlength) == moduleextension)
+                    {
+                        // We've found a helper file - now load the library with the same name
+                        std::string library = filename.substr(0, filename.size() - moduleextensionlength);
+                        boost::filesystem::path librarypath = searchpath / library;
+                        try
+                        {
+                            DynLibManager::getInstance().load(librarypath.string());
+                        }
+                        catch (...)
+                        {
+                            COUT(1) << "Couldn't load module \"" << librarypath.string() << "\": " << Exception::handleMessage() << std::endl;
+                        }
+                    }
+                }
+                ++file;
+                this->dynLibManager_->load(*it);
+            }
+        }
         catch (...)
+        {
             COUT(1) << "An error occurred while loading modules: " << Exception::handleMessage() << std::endl;
+            catch (...)
+            {
+                COUT(1) << "Couldn't load module \"" << *it << "\": " << Exception::handleMessage() << std::endl;
+            }
+        }
 …
         // Set configurable paths like log, config and media
         this->setConfigurablePaths();
+        this->pathConfig_->setConfigurablePaths();
         // create a signal handler (only active for linux)
         // This call is placed as soon as possible, but after the directories are set
         this->signalHandler_.reset(new SignalHandler());
         this->signalHandler_->doCatch(configuration_->executablePath_.string(), Core::getLogPathString() + "orxonox_crash.log");
+        this->signalHandler_->doCatch(PathConfig::getExecutablePathString(), PathConfig::getLogPathString() + "orxonox_crash.log");
         // Set the correct log path. Before this call, /tmp (Unix) or %TEMP% was used
         OutputHandler::getOutStream().setLogPath(Core::getLogPathString());
+        OutputHandler::getOutStream().setLogPath(PathConfig::getLogPathString());
         // Parse additional options file now that we know its path
 …
         // creates the class hierarchy for all classes with factories
         Factory::createClassHierarchy();
+        Identifier::createClassHierarchy();
         // Do this soon after the ConfigFileManager has been created to open up the
 …
         // initialise Tcl
         this->tclBind_.reset(new TclBind(Core::getDataPathString()));
+        this->tclBind_.reset(new TclBind(PathConfig::getDataPathString()));
         this->tclThreadManager_.reset(new TclThreadManager(tclBind_->getTclInterpreter()));
         // create a shell
         this->shell_.reset(new Shell());
+        // Create singletons that always exist (in other libraries)
+        this->rootScope_.reset(new Scope<ScopeID::Root>());
+    }
 …
         inputManager_.reset(new InputManager());
         // load the CEGUI interface
+        // Load the CEGUI interface
         guiManager_.reset(new GUIManager(graphicsManager_->getRenderWindow(),
             inputManager_->getMousePosition(), graphicsManager_->isFullScreen()));
+        bGraphicsLoaded_ = true;
+        GameMode::bShowsGraphics_s = true;
+        // Load some sort of a debug overlay (only denoted by its name, "debug.oxo")
+        graphicsManager_->loadDebugOverlay();
+        // Create singletons associated with graphics (in other libraries)
+        graphicsScope_.reset(new Scope<ScopeID::Graphics>());
         unloader.Dismiss();
-        bGraphicsLoaded_ = true;
+    }
     void Core::unloadGraphics()
+    {
+        this->guiManager_.reset();;
+        this->inputManager_.reset();;
+        this->graphicsScope_.reset();
+        this->guiManager_.reset();
+        this->inputManager_.reset();
         this->graphicsManager_.reset();
 …
         bGraphicsLoaded_ = false;
+        GameMode::bShowsGraphics_s = false;
+    }
 …
+    }
-    /*static*/ void Core::tsetExternalDataPath(const std::string& path)
+    {
-        getInstance().configuration_->tsetExternalDataPath(path);
+    }
-    /*static*/ const boost::filesystem::path& Core::getDataPath()
+    {
-        return getInstance().configuration_->dataPath_;
+    }
-    /*static*/ std::string Core::getDataPathString()
+    {
-        return getInstance().configuration_->dataPath_.string() + '/';
+    }
-    /*static*/ const boost::filesystem::path& Core::getExternalDataPath()
+    {
-        return getInstance().configuration_->externalDataPath_;
+    }
-    /*static*/ std::string Core::getExternalDataPathString()
+    {
-        return getInstance().configuration_->externalDataPath_.string() + '/';
+    }
-    /*static*/ const boost::filesystem::path& Core::getConfigPath()
+    {
-        return getInstance().configuration_->configPath_;
+    }
-    /*static*/ std::string Core::getConfigPathString()
+    {
-        return getInstance().configuration_->configPath_.string() + '/';
+    }
-    /*static*/ const boost::filesystem::path& Core::getLogPath()
+    {
-        return getInstance().configuration_->logPath_;
+    }
-    /*static*/ std::string Core::getLogPathString()
+    {
-        return getInstance().configuration_->logPath_.string() + '/';
+    }
-    /*static*/ const boost::filesystem::path& Core::getRootPath()
+    {
-        return getInstance().configuration_->rootPath_;
+    }
-    /*static*/ std::string Core::getRootPathString()
+    {
-        return getInstance().configuration_->rootPath_.string() + '/';
+    }
     /**
     @note
 …
+    }
-    /**
-    @brief
-        Retrievs the executable path and sets all hard coded fixed path (currently only the module path)
-        Also checks for "orxonox_dev_build.keep_me" in the executable diretory.
-        If found it means that this is not an installed run, hence we
-        don't write the logs and config files to ~/.orxonox
-    @throw
-        GeneralException
-    */
-    void Core::setFixedPaths()
+    {
-        //////////////////////////
-        // FIND EXECUTABLE PATH //
-        //////////////////////////
-#ifdef ORXONOX_PLATFORM_WINDOWS
-        // get executable module
-        TCHAR buffer[1024];
-        if (GetModuleFileName(NULL, buffer, 1024) == 0)
-            ThrowException(General, "Could not retrieve executable path.");
-#elif defined(ORXONOX_PLATFORM_APPLE)
-        char buffer[1024];
-        unsigned long path_len = 1023;
-        if (_NSGetExecutablePath(buffer, &path_len))
-            ThrowException(General, "Could not retrieve executable path.");
-#else /* Linux */
-        /* written by Nicolai Haehnle <prefect_@gmx.net> */
-        /* Get our PID and build the name of the link in /proc */
-        char linkname[64]; /* /proc/<pid>/exe */
-        if (snprintf(linkname, sizeof(linkname), "/proc/%i/exe", getpid()) < 0)
+        {
-            /* This should only happen on large word systems. I'm not sure
-               what the proper response is here.
-               Since it really is an assert-like condition, aborting the
-               program seems to be in order. */
-            assert(false);
+        }
-        /* Now read the symbolic link */
-        char buffer[1024];
-        int ret;
-        ret = readlink(linkname, buffer, 1024);
-        /* In case of an error, leave the handling up to the caller */
-        if (ret == -1)
-            ThrowException(General, "Could not retrieve executable path.");
-        /* Ensure proper NUL termination */
-        buffer[ret] = 0;
-#endif
-        configuration_->executablePath_ = boost::filesystem::path(buffer);
-#ifndef ORXONOX_PLATFORM_APPLE
-        configuration_->executablePath_ = configuration_->executablePath_.branch_path(); // remove executable name
-#endif
-        /////////////////////
-        // SET MODULE PATH //
-        /////////////////////
-        if (boost::filesystem::exists(configuration_->executablePath_ / "orxonox_dev_build.keep_me"))
+        {
-            COUT(1) << "Running from the build tree." << std::endl;
-            Core::bDevRun_ = true;
-            configuration_->modulePath_ = specialConfig::moduleDevDirectory;
+        }
-        else
+        {
-#ifdef INSTALL_COPYABLE // --> relative paths
-            // Also set the root path
-            boost::filesystem::path relativeExecutablePath(specialConfig::defaultRuntimePath);
-            configuration_->rootPath_ = configuration_->executablePath_;
-            while (!boost::filesystem::equivalent(configuration_->rootPath_ / relativeExecutablePath, configuration_->executablePath_)
-                   && !configuration_->rootPath_.empty())
-                configuration_->rootPath_ = configuration_->rootPath_.branch_path();
-            if (configuration_->rootPath_.empty())
-                ThrowException(General, "Could not derive a root directory. Might the binary installation directory contain '..' when taken relative to the installation prefix path?");
-            // Module path is fixed as well
-            configuration_->modulePath_ = configuration_->rootPath_ / specialConfig::defaultModulePath;
-#else
-            // There is no root path, so don't set it at all
-            // Module path is fixed as well
-            configuration_->modulePath_ = specialConfig::moduleInstallDirectory;
-#endif
+        }
+    }
-    /**
-    @brief
-        Sets config, log and media path and creates folders if necessary.
-    @throws
-        GeneralException
-    */
-    void Core::setConfigurablePaths()
+    {
-        if (Core::isDevelopmentRun())
+        {
-            configuration_->dataPath_  = specialConfig::dataDevDirectory;
-            configuration_->externalDataPath_ = specialConfig::externalDataDevDirectory;
-            configuration_->configPath_ = specialConfig::configDevDirectory;
-            configuration_->logPath_    = specialConfig::logDevDirectory;
+        }
-        else
+        {
-#ifdef INSTALL_COPYABLE // --> relative paths
-            // Using paths relative to the install prefix, complete them
-            configuration_->dataPath_   = configuration_->rootPath_ / specialConfig::defaultDataPath;
-            configuration_->configPath_ = configuration_->rootPath_ / specialConfig::defaultConfigPath;
-            configuration_->logPath_    = configuration_->rootPath_ / specialConfig::defaultLogPath;
-#else
-            configuration_->dataPath_  = specialConfig::dataInstallDirectory;
-            // Get user directory
-#  ifdef ORXONOX_PLATFORM_UNIX /* Apple? */
-            char* userDataPathPtr(getenv("HOME"));
-#  else
-            char* userDataPathPtr(getenv("APPDATA"));
-#  endif
-            if (userDataPathPtr == NULL)
-                ThrowException(General, "Could not retrieve user data path.");
-            boost::filesystem::path userDataPath(userDataPathPtr);
-            userDataPath /= ".orxonox";
-            configuration_->configPath_ = userDataPath / specialConfig::defaultConfigPath;
-            configuration_->logPath_    = userDataPath / specialConfig::defaultLogPath;
-#endif
+        }
-        // Option to put all the config and log files in a separate folder
-        if (!CommandLine::getArgument("writingPathSuffix")->hasDefaultValue())
+        {
-            std::string directory(CommandLine::getValue("writingPathSuffix").getString());
-            configuration_->configPath_ = configuration_->configPath_ / directory;
-            configuration_->logPath_    = configuration_->logPath_    / directory;
+        }
-        // Create directories to avoid problems when opening files in non existent folders.
-        std::vector<std::pair<boost::filesystem::path, std::string> > directories;
-        directories.push_back(std::make_pair(boost::filesystem::path(configuration_->configPath_), "config"));
-        directories.push_back(std::make_pair(boost::filesystem::path(configuration_->logPath_), "log"));
-        for (std::vector<std::pair<boost::filesystem::path, std::string> >::iterator it = directories.begin();
-            it != directories.end(); ++it)
+        {
-            if (boost::filesystem::exists(it->first) && !boost::filesystem::is_directory(it->first))
+            {
-                ThrowException(General, std::string("The ") + it->second + " directory has been preoccupied by a file! \
-                                         Please remove " + it->first.string());
+            }
-            if (boost::filesystem::create_directories(it->first)) // function may not return true at all (bug?)
+            {
-                COUT(4) << "Created " << it->second << " directory" << std::endl;
+            }
+        }
+    }
     void Core::preUpdate(const Clock& time)
+    {
+        // singletons from other libraries
+        ScopedSingletonManager::update<ScopeID::Root>(time);
         if (this->bGraphicsLoaded_)
+        {
 …
             // process gui events
             this->guiManager_->update(time);
+            // graphics singletons from other libraries
+            ScopedSingletonManager::update<ScopeID::Graphics>(time);
+        }
         // process thread commands

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

-                      r5781
+                      r5929
  */
-/**
-@file
-@brief
-    Declaration of the Core class.
-@details
-    The Core class is a singleton, only used to configure some variables
-    in the core through the config-file.
-*/
 #ifndef _Core_H__
 #define _Core_H__
 …
 #include <boost/scoped_ptr.hpp>
 #include "util/OutputHandler.h"
+#include "util/Scope.h"
 #include "util/ScopeGuard.h"
 #include "util/Singleton.h"
 …
     @brief
         The Core class is a singleton used to configure the program basics.
-    @details
-        The class provides information about the data, 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!
 …
             static void  resetLanguage();
-            static void tsetExternalDataPath(const std::string& path);
-            //! Returns the path to the data files as boost::filesystem::path
-            static const boost::filesystem::path& getDataPath();
-            //! Returns the path to the external data files as boost::filesystem::path
-            static const boost::filesystem::path& getExternalDataPath();
-            //! Returns the path to the config files as boost::filesystem::path
-            static const boost::filesystem::path& getConfigPath();
-            //! 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 getDataPathString();
-            //! Returns the path to the external data files as std::string
-            static std::string getExternalDataPathString();
-            //! Returns the path to the config files as std::string
-            static std::string getConfigPathString();
-            //! 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:
             Core(const Core&); //!< Don't use (undefined symbol)
 …
             void unloadGraphics();
-            void setFixedPaths();
-            void setConfigurablePaths();
             void setThreadAffinity(int limitToCPU);
             // Mind the order for the destruction!
+            scoped_ptr<PathConfig>        pathConfig_;
             scoped_ptr<DynLibManager>     dynLibManager_;
             scoped_ptr<SignalHandler>     signalHandler_;
 …
             scoped_ptr<InputManager>      inputManager_;        //!< Interface to OIS
             scoped_ptr<GUIManager>        guiManager_;          //!< Interface to GUI
+            scoped_ptr<Scope<ScopeID::Root> >     rootScope_;
+            scoped_ptr<Scope<ScopeID::Graphics> > graphicsScope_;
-            bool                          bDevRun_;             //!< True for runs in the build directory (not installed)
             bool                          bGraphicsLoaded_;
             static Core* singletonPtr_s;
     };

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

-                      r5781
+                      r5929
 /**
     @file
     @brief Definition of macros for Identifier and Factory.
+    @brief Definition of macros for Identifiers
     Every class needs the RegisterObject(class) macro in its constructor. If the class is an interface
 …
 #include "util/Debug.h"
 #include "Identifier.h"
 #include "Factory.h"
+#include "SubclassIdentifier.h"
 #include "ClassFactory.h"
 #include "ObjectList.h"
 …
 /**
     @brief Creates the entry in the Factory.
+    @brief Creates the Factory.
     @param ClassName The name of the class
 */
 #define CreateFactory(ClassName) \
     bool bCreated##ClassName##Factory = orxonox::ClassFactory<ClassName>::create(#ClassName, true)
+    Factory* _##ClassName##Factory = new orxonox::ClassFactory<ClassName>(#ClassName, true)
 /**
     @brief Creates the entry in the Factory for classes which should not be loaded through XML.
+    @brief Creates the Factory for classes which should not be loaded through XML.
     @param ClassName The name of the class
 */
 #define CreateUnloadableFactory(ClassName) \
     bool bCreated##ClassName##Factory = orxonox::ClassFactory<ClassName>::create(#ClassName, false)
+    Factory* _##ClassName##Factory = new orxonox::ClassFactory<ClassName>(#ClassName, false)
 /**
 …
+{
     /**
         @brief Returns the Identifier with a given name through the factory.
+        @brief Returns the Identifier with a given name.
         @param String The name of the class
     */
     inline Identifier* ClassByString(const std::string& name)
+    {
         return Factory::getIdentifier(name);
+        return Identifier::getIdentifierByString(name);
+    }
     /**
+        @brief Returns the Identifier with a given network ID through the factory.
+        @brief Returns the Identifier with a given lowercase name.
+        @param String The lowercase name of the class
+    */
+    inline Identifier* ClassByLowercaseString(const std::string& name)
+    {
+        return Identifier::getIdentifierByLowercaseString(name);
+    }
+    /**
+        @brief Returns the Identifier with a given network ID.
         @param networkID The network ID of the class
     */
     inline Identifier* ClassByID(uint32_t id)
+    {
         return Factory::getIdentifier(id);
+        return Identifier::getIdentifierByID(id);
+    }
+}

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

-                      r5738
+                      r5929
 /**
+  @file
+  @brief Contains all the necessary forward declarations for all classes and structs.
+@file
+@brief
+    Shared library macros, enums, constants and forward declarations for the core library
 */
 …
 // Shared library settings
 //-----------------------------------------------------------------------
 #if defined(ORXONOX_PLATFORM_WINDOWS) && !defined( CORE_STATIC_BUILD )
 #  ifdef CORE_SHARED_BUILD
 …
 #endif
+//-----------------------------------------------------------------------
+// Forward declarations
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+// Constants
+//-----------------------------------------------------------------------
+namespace orxonox
+{
+    static const uint32_t OBJECTID_UNKNOWN = static_cast<uint32_t>(-1);
+}
+//-----------------------------------------------------------------------
+// Enums
+//-----------------------------------------------------------------------
 namespace orxonox
+{
 …
         enum Mode
+        {
+            NOP,
             LoadObject,
             SaveObject,
 …
         };
     };
+}
+//-----------------------------------------------------------------------
+// Forward declarations
+//-----------------------------------------------------------------------
+namespace orxonox
+{
     typedef std::string LanguageEntryLabel;
     class ArgumentCompleter;
     class ArgumentCompletionListElement;
-    class BaseFactory;
-    class BaseMetaObjectListElement;
     class BaseObject;
     template <class T>
 …
     class ClassTreeMaskNode;
     class ClassTreeMaskObjectIterator;
-    class Clock;
     class CommandEvaluation;
-    class CommandExecutor;
     class CommandLine;
     class CommandLineArgument;
 …
     class ConfigFileManager;
     class ConfigFileSection;
+    struct ConfigFileType;
     class ConfigValueContainer;
     class ConsoleCommand;
 …
     class DynLibManager;
     struct Event;
     class EventContainer;
+    class EventState;
     class Executor;
     template <class T>
 …
     class FunctorMember;
     class FunctorStatic;
+    class Game;
+    class GameState;
+    struct GameStateInfo;
+    struct GameStateTreeNode;
     class GraphicsManager;
     class GUIManager;
 …
     template <class T>
     class Iterator;
-    class IteratorBase;
     class Language;
-    class LanguageEntry;
-    class Loader;
     class LuaState;
     class MemoryArchive;
 …
     class OgreWindowEventListener;
     class OrxonoxClass;
+    class PathConfig;
     struct ResourceInfo;
     class Shell;
     class ShellListener;
     template <class T>
+    class SmartPtr;
+    template <class T>
     class SubclassIdentifier;
     class TclBind;
 …
     class TclThreadManager;
     class Template;
+    class Thread;
+    class ThreadPool;
+    template <class T>
+    class WeakPtr;
     class WindowEventListener;
     class XMLFile;
 …
     class XMLPortParamContainer;
+    // game states
+    class Game;
+    class GameState;
+    struct GameStateInfo;
+    struct GameStateTreeNode;
+    // input
+    // Input
     class BaseCommand;
     class BufferedParamCommand;
     class Button;
-    class CalibratorCallback;
     class HalfAxis;
     class InputBuffer;
 …
     class InputManager;
     class InputState;
+    struct InputStatePriority;
+    class JoyStickQuantityListener;
     class JoyStick;
+    class KeyBinder;
+    class KeyBinderManager;
+    class Keyboard;
+    class KeyDetector;
+    class KeyEvent;
     class Mouse;
-    class Keyboard;
-    class KeyBinder;
-    class KeyDetector;
     class ParamCommand;
     class SimpleCommand;
-    // multithreading
-    class Thread;
-    class ThreadPool;
+}
 …
 namespace orxonox
+{
-    using ticpp::Document;
     using ticpp::Element;
+    using ticpp::Declaration;
+    using ticpp::StylesheetReference;
+    using ticpp::Text;
+    using ticpp::Comment;
+    using ticpp::Attribute;
+}
+}
 #endif /* _CorePrereqs_H__ */

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

-                      r5781
+                      r5929
 #include "BaseObject.h"
 #include "Executor.h"
+#include "Identifier.h"
 namespace orxonox
+{
+    EventContainer::~EventContainer()
+    /**
+        @brief Destructor: Deletes the functor of the event state.
+    */
+    EventState::~EventState()
+    {
+        delete this->eventfunction_;
+        if (this->statefunction_)
+            delete this->statefunction_;
+    }
+    void EventContainer::process(BaseObject* object, const Event& event)
+    /**
+        @brief Processes an event (calls the set-function if the necessary conditions are met).
+        @param event     The fired event
+        @param object    The object whose state is affected by the event (only needed for debug output)
+    */
+    void EventState::process(const Event& event, BaseObject* object)
+    {
         if (this->bActive_)
+        if (this->bProcessingEvent_)
+        {
             COUT(2) << "Warning: Detected Event loop in section \"" << this->eventname_ << "\" of object \"" << object->getName() << "\" and fired by \"" << event.originator_->getName() << "\"" << std::endl;
+            COUT(2) << "Warning: Detected Event loop in section \"" << event.statename_ << "\" of object \"" << object->getName() << "\" and fired by \"" << event.originator_->getName() << "\"" << std::endl;
             return;
+        }
         this->bActive_ = true;
+        this->bProcessingEvent_ = true;
+        if (this->eventname_ == event.sectionname_)
+        // check if the originator is an instance of the requested class
+        if (event.originator_->isA(this->subclass_))
+        {
+            if (event.originator_->isA(this->subclass_))
+            // actualize the activationcounter
+            if (event.activate_)
+                ++this->activeEvents_;
+            else
+            {
+                if (event.activate_)
+                    ++this->activeEvents_;
+                else
+                --this->activeEvents_;
+                if (this->activeEvents_ < 0)
+                    this->activeEvents_ = 0;
+            }
+            if (this->statefunction_->getParamCount() == 0 && event.activate_)
+            {
+                // if the eventfunction doesn't have a state, just call it whenever an activation-event comes in
+                (*this->statefunction_)();
+            }
+            else if ((this->activeEvents_ == 1 && event.activate_) || (this->activeEvents_ == 0 && !event.activate_))
+            {
+                // if the eventfunction needs a state, we just call the function if the state changed from 0 to 1 (state = true) or from 1 to 0 (state = false) [but not if activeEvents_ is > 1]
+                if (this->statefunction_->getParamCount() == 1)
+                {
+                    --this->activeEvents_;
+                    if (this->activeEvents_ < 0)
+                        this->activeEvents_ = 0;
+                    // one argument: just the eventstate
+                    (*this->statefunction_)(this->activeEvents_);
+                }
+                if (this->eventfunction_->getParamCount() == 0 && event.activate_)
+                    (*this->eventfunction_)();
+                else if ((this->activeEvents_ == 1 && event.activate_) || (this->activeEvents_ == 0 && !event.activate_))
+                else if (this->statefunction_->getParamCount() >= 2)
+                {
+                    if (this->eventfunction_->getParamCount() == 1)
+                        (*this->eventfunction_)(this->activeEvents_);
+                    else if (this->eventfunction_->getParamCount() >= 2 && event.castedOriginator_)
+                        (*this->eventfunction_)(this->activeEvents_, event.castedOriginator_);
+                    // two arguments: the eventstate and the originator
+                    if (this->subclass_->isExactlyA(ClassIdentifier<BaseObject>::getIdentifier()))
+                    {
+                        // if the subclass is BaseObject, we don't have to cast the pointer
+                        (*this->statefunction_)(this->activeEvents_, event.originator_);
+                    }
+                    else
+                    {
+                        // else cast the pointer to the desired class
+                        void* castedOriginator = event.originator_->getDerivedPointer(this->subclass_->getClassID());
+                        (*this->statefunction_)(this->activeEvents_, castedOriginator);
+                    }
+                }
+            }
+        }
         this->bActive_ = false;
+        this->bProcessingEvent_ = false;
+    }
+}

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

-                      r5781
+                      r5929
 namespace orxonox
+{
+    /**
+        @brief The Event struct contains information about a fired Event.
+    */
     struct _CoreExport Event
+    {
             Event(bool activate, BaseObject* originator) : activate_(activate), originator_(originator), castedOriginator_(0) {}
+        Event(bool activate, BaseObject* originator, const std::string& name) : activate_(activate), originator_(originator), name_(name) {}
             bool        activate_;
             BaseObject* originator_;
             void*       castedOriginator_;
             std::string sectionname_;
+        bool        activate_;   //!< True if this is an activating event (the event source was inactive before and just triggered the event) - false otherwise
+        std::string statename_;  //!< The name of the state this event affects
+        BaseObject* originator_; //!< The object which triggered this event
+        std::string name_;       //!< The name of this event
     };
+    class _CoreExport EventContainer
+    /**
+        @brief The EventState contains information about an event state.
+        An event state is a state of an object, which can be changed by events.
+        Event states are changed through functions. Possible functions headers for set event states are:
+         - memoryless state: function()
+         - boolean state:    function(bool state)
+         - individual state: function(bool state, SomeClass originator)
+        Note that SomeClass may be any class deriving from BaseObject. You will not receive events from originators of other classes.
+        The actual class for SomeClass must be specified as the second argument of the XMLPortEventState macro.
+        The this pointer of the affected object is hidden in the functors, because the events are processed in the BaseObject, but some
+        statefunctions may be from child-classes.
+    */
+    class _CoreExport EventState
+    {
         public:
             EventContainer(const std::string& eventname, Executor* eventfunction, Identifier* subclass) : bActive_(false), eventname_(eventname), eventfunction_(eventfunction), subclass_(subclass), activeEvents_(0) {}
             virtual ~EventContainer();
+            EventState(Functor* statefunction, Identifier* subclass) : bProcessingEvent_(false), activeEvents_(0), statefunction_(statefunction), subclass_(subclass) {}
+            virtual ~EventState();
+            void process(BaseObject* object, const Event& event);
+            void process(const Event& event, BaseObject* object);
+            Functor* getFunctor() const
+                { return this->statefunction_; }
         private:
+            bool bActive_;
+            std::string eventname_;
+            Executor* eventfunction_;
+            Identifier* subclass_;
+            int activeEvents_;
+            bool        bProcessingEvent_;  //!< This becomes true while the container processes an event (used to prevent loops)
+            int         activeEvents_;      //!< The number of events which affect this state and are currently active
+            Functor*    statefunction_;     //!< A functor to set the state
+            Identifier* subclass_;          //!< Originators must be an instance of this class (usually BaseObject, but some statefunctions allow a second argument with an originator of a specific class)
     };
+}

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

-                      r5781
+                      r5929
 #include "CorePrereqs.h"
 #include "Executor.h"
+#include "XMLPort.h"
+#define ORXONOX_SET_EVENT(classname, eventname, functionname, event) \
+    ORXONOX_SET_EVENT_GENERIC(eventcontainer##classname##functionname, classname, eventname, functionname, event, BaseObject)
+/**
+    @brief Defines a new event state (a state of the object which can be changed by events).
+    @param classname    The name of this class
+    @param subclassname Usually BaseObject - if different, only instances of this class can send events to this object
+    @param statename    The name (string) of this state
+    @param function     The function which should be used to set the state
+    @param xmlelement   Argument for XMLPort
+    @param mode         Argument for XMLPort
+*/
+#define XMLPortEventState(classname, subclassname, statename, function, xmlelement, mode) \
+    orxonox::EventState* containername##function = this->getEventState(statename); \
+    if (!containername##function) \
+    { \
+        containername##function = new orxonox::EventState(orxonox::createFunctor(&classname::function, this), orxonox::ClassIdentifier<subclassname>::getIdentifier()); \
+        this->addEventState(statename, containername##function); \
+    } \
+    XMLPortEventStateIntern(xmlportevent##function, classname, statename, xmlelement, mode)
+#define ORXONOX_SET_EVENT_TEMPLATE(classname, eventname, functionname, event, ...) \
+    ORXONOX_SET_EVENT_GENERIC_TEMPLATE(eventcontainer##classname##functionname, classname, eventname, functionname, event, BaseObject, __VA_ARGS__)
+/**
+    @brief Like XMLPortEventState but with additional template arguments to identify the function of the state (if ambiguous).
+*/
+#define XMLPortEventStateTemplate(classname, subclassname, statename, function, xmlelement, mode, ...) \
+    orxonox::EventState* containername##function = this->getEventState(statename); \
+    if (!containername##function) \
+    { \
+        containername##function = new orxonox::EventState(orxonox::createFunctor<classname, __VA_ARGS__ >(&classname::function, this), orxonox::ClassIdentifier<subclassname>::getIdentifier()); \
+        this->addEventState(statename, containername##function); \
+    } \
+    XMLPortEventStateIntern(xmlportevent##function, classname, statename, xmlelement, mode)
+#define ORXONOX_SET_SUBCLASS_EVENT(classname, eventname, functionname, event, subclassname) \
+    ORXONOX_SET_EVENT_GENERIC(eventcontainer##classname##functionname, classname, eventname, functionname, event, subclassname)
+#define XMLPortEventStateIntern(name, classname, statename, xmlelement, mode) \
+    static orxonox::ExecutorMember<classname>* xmlsetfunctor##name = (orxonox::ExecutorMember<classname>*)&orxonox::createExecutor(orxonox::createFunctor(&classname::addEventSource), std::string( #classname ) + "::" + "addEventSource" + "(" + statename + ")")->setDefaultValue(1, statename); \
+    static orxonox::ExecutorMember<classname>* xmlgetfunctor##name = (orxonox::ExecutorMember<classname>*)&orxonox::createExecutor(orxonox::createFunctor(&classname::getEventSource), std::string( #classname ) + "::" + "getEventSource" + "(" + statename + ")")->setDefaultValue(1, statename); \
+    XMLPortObjectGeneric(xmlport##name, classname, orxonox::BaseObject, statename, xmlsetfunctor##name, xmlgetfunctor##name, xmlelement, mode, false, true)
+#define ORXONOX_SET_SUBCLASS_EVENT_TEMPLATE(classname, eventname, functionname, event, subclassname, ...) \
+    ORXONOX_SET_EVENT_GENERIC_TEMPLATE(eventcontainer##classname##functionname, classname, eventname, functionname, event, subclassname, __VA_ARGS__)
+/**
+    @brief Defines a new event name for a class. Named events can only have names which were defined with this macro.
+    @param classname The name of the class
+    @param name      The name of the event
+*/
+#define CreateEventName(classname, name) \
+    static std::string eventname##classname##name = #name
+#define ORXONOX_SET_EVENT_GENERIC(containername, classname, eventname, functionname, event, subclassname) \
+    orxonox::EventContainer* containername = this->getEventContainer(eventname); \
+    if (!containername) \
+    { \
+        ExecutorMember<classname>* executor = orxonox::createExecutor(orxonox::createFunctor(&classname::functionname), std::string( #classname ) + "::" + #functionname); \
+        executor->setObject(this); \
+        containername = new orxonox::EventContainer(std::string(eventname), executor, orxonox::ClassIdentifier<subclassname>::getIdentifier()); \
+        this->addEventContainer(eventname, containername); \
+    } \
+    event.castedOriginator_ = orxonox::orxonox_cast<subclassname*>(event.originator_); \
+    containername->process(this, event)
+#define ORXONOX_SET_EVENT_GENERIC_TEMPLATE(containername, classname, eventname, functionname, event, subclassname, ...) \
+    orxonox::EventContainer* containername = this->getEventContainer(eventname); \
+    if (!containername) \
+    { \
+        ExecutorMember<classname>* executor = orxonox::createExecutor(orxonox::createFunctor<classname, __VA_ARGS__ >(&classname::functionname), std::string( #classname ) + "::" + #functionname); \
+        executor->setObject(this); \
+        containername = new orxonox::EventContainer(std::string(eventname), executor, orxonox::ClassIdentifier<subclassname>::getIdentifier()); \
+        this->addEventContainer(eventname, containername); \
+    } \
+    event.castedOriginator_ = orxonox::orxonox_cast<subclassname*>(event.originator_); \
+    containername->process(this, event)
+/**
+    @brief This macro is needed to fire an event with this name. The event name must previously be declared with @ref CreateEventName.
+*/
+#define FireEventName(classname, name) \
+    eventname##classname##name
 #endif /* _EventIncludes_H__ */

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

-                      r5738
+                      r5929
+#define FUNCTOR_TEMPLATE(ismember, returnvalue, numparams) FUNCTOR_TEMPLATE##ismember##returnvalue##numparams
+#define FUNCTOR_TEMPLATE000
+#define FUNCTOR_TEMPLATE001 template <class P1>
+#define FUNCTOR_TEMPLATE002 template <class P1, class P2>
+#define FUNCTOR_TEMPLATE003 template <class P1, class P2, class P3>
+#define FUNCTOR_TEMPLATE004 template <class P1, class P2, class P3, class P4>
+#define FUNCTOR_TEMPLATE005 template <class P1, class P2, class P3, class P4, class P5>
+#define FUNCTOR_TEMPLATE010 template <class R>
+#define FUNCTOR_TEMPLATE011 template <class R, class P1>
+#define FUNCTOR_TEMPLATE012 template <class R, class P1, class P2>
+#define FUNCTOR_TEMPLATE013 template <class R, class P1, class P2, class P3>
+#define FUNCTOR_TEMPLATE014 template <class R, class P1, class P2, class P3, class P4>
+#define FUNCTOR_TEMPLATE015 template <class R, class P1, class P2, class P3, class P4, class P5>
+#define FUNCTOR_TEMPLATE100 template <class T>
+#define FUNCTOR_TEMPLATE101 template <class T, class P1>
+#define FUNCTOR_TEMPLATE102 template <class T, class P1, class P2>
+#define FUNCTOR_TEMPLATE103 template <class T, class P1, class P2, class P3>
+#define FUNCTOR_TEMPLATE104 template <class T, class P1, class P2, class P3, class P4>
+#define FUNCTOR_TEMPLATE105 template <class T, class P1, class P2, class P3, class P4, class P5>
+#define FUNCTOR_TEMPLATE110 template <class T, class R>
+#define FUNCTOR_TEMPLATE111 template <class T, class R, class P1>
+#define FUNCTOR_TEMPLATE112 template <class T, class R, class P1, class P2>
+#define FUNCTOR_TEMPLATE113 template <class T, class R, class P1, class P2, class P3>
+#define FUNCTOR_TEMPLATE114 template <class T, class R, class P1, class P2, class P3, class P4>
+#define FUNCTOR_TEMPLATE115 template <class T, class R, class P1, class P2, class P3, class P4, class P5>
+#define FUNCTOR_TEMPLATE(ismember, returnvalue, numparams, additionalobject) FUNCTOR_TEMPLATE##ismember##returnvalue##numparams(additionalobject)
+#define FUNCTOR_TEMPLATE000(additionalobject)
+#define FUNCTOR_TEMPLATE001(additionalobject) template <class P1>
+#define FUNCTOR_TEMPLATE002(additionalobject) template <class P1, class P2>
+#define FUNCTOR_TEMPLATE003(additionalobject) template <class P1, class P2, class P3>
+#define FUNCTOR_TEMPLATE004(additionalobject) template <class P1, class P2, class P3, class P4>
+#define FUNCTOR_TEMPLATE005(additionalobject) template <class P1, class P2, class P3, class P4, class P5>
+#define FUNCTOR_TEMPLATE010(additionalobject) template <class R>
+#define FUNCTOR_TEMPLATE011(additionalobject) template <class R, class P1>
+#define FUNCTOR_TEMPLATE012(additionalobject) template <class R, class P1, class P2>
+#define FUNCTOR_TEMPLATE013(additionalobject) template <class R, class P1, class P2, class P3>
+#define FUNCTOR_TEMPLATE014(additionalobject) template <class R, class P1, class P2, class P3, class P4>
+#define FUNCTOR_TEMPLATE015(additionalobject) template <class R, class P1, class P2, class P3, class P4, class P5>
+#define FUNCTOR_TEMPLATE100(additionalobject) template <class T FUNCTOR_TEMPLATE_ADDITIONAL_OBJECT(additionalobject) >
+#define FUNCTOR_TEMPLATE101(additionalobject) template <class T, class P1 FUNCTOR_TEMPLATE_ADDITIONAL_OBJECT(additionalobject) >
+#define FUNCTOR_TEMPLATE102(additionalobject) template <class T, class P1, class P2 FUNCTOR_TEMPLATE_ADDITIONAL_OBJECT(additionalobject) >
+#define FUNCTOR_TEMPLATE103(additionalobject) template <class T, class P1, class P2, class P3 FUNCTOR_TEMPLATE_ADDITIONAL_OBJECT(additionalobject) >
+#define FUNCTOR_TEMPLATE104(additionalobject) template <class T, class P1, class P2, class P3, class P4 FUNCTOR_TEMPLATE_ADDITIONAL_OBJECT(additionalobject) >
+#define FUNCTOR_TEMPLATE105(additionalobject) template <class T, class P1, class P2, class P3, class P4, class P5 FUNCTOR_TEMPLATE_ADDITIONAL_OBJECT(additionalobject) >
+#define FUNCTOR_TEMPLATE110(additionalobject) template <class T, class R FUNCTOR_TEMPLATE_ADDITIONAL_OBJECT(additionalobject) >
+#define FUNCTOR_TEMPLATE111(additionalobject) template <class T, class R, class P1 FUNCTOR_TEMPLATE_ADDITIONAL_OBJECT(additionalobject) >
+#define FUNCTOR_TEMPLATE112(additionalobject) template <class T, class R, class P1, class P2 FUNCTOR_TEMPLATE_ADDITIONAL_OBJECT(additionalobject) >
+#define FUNCTOR_TEMPLATE113(additionalobject) template <class T, class R, class P1, class P2, class P3 FUNCTOR_TEMPLATE_ADDITIONAL_OBJECT(additionalobject) >
+#define FUNCTOR_TEMPLATE114(additionalobject) template <class T, class R, class P1, class P2, class P3, class P4 FUNCTOR_TEMPLATE_ADDITIONAL_OBJECT(additionalobject) >
+#define FUNCTOR_TEMPLATE115(additionalobject) template <class T, class R, class P1, class P2, class P3, class P4, class P5 FUNCTOR_TEMPLATE_ADDITIONAL_OBJECT(additionalobject) >
+#define FUNCTOR_TEMPLATE_ADDITIONAL_OBJECT(additionalobject) FUNCTOR_TEMPLATE_ADDITIONAL_OBJECT##additionalobject
+#define FUNCTOR_TEMPLATE_ADDITIONAL_OBJECT0
+#define FUNCTOR_TEMPLATE_ADDITIONAL_OBJECT1 , class O
 …
 #define CREATE_STATIC_FUNCTOR(returnvalue, numparams) \
     FUNCTOR_TEMPLATE(0, returnvalue, numparams) \
+    FUNCTOR_TEMPLATE(0, returnvalue, numparams, 0) \
     class FunctorStatic##returnvalue##numparams : public FunctorStatic \
     { \
 …
+    \
+    \
     FUNCTOR_TEMPLATE(0, returnvalue, numparams) \
+    FUNCTOR_TEMPLATE(0, returnvalue, numparams, 0) \
     inline FunctorStatic##returnvalue##numparams FUNCTOR_TEMPLATE_CLASSES(0, returnvalue, numparams)* createFunctor(FUNCTOR_FUNCTION_RETURNVALUE(returnvalue) (*functionPointer)(FUNCTOR_FUNCTION_PARAMS(numparams))) \
     { \
 …
 #define CREATE_MEMBER_FUNCTOR(returnvalue, numparams) \
     FUNCTOR_TEMPLATE(1, returnvalue, numparams) \
+    FUNCTOR_TEMPLATE(1, returnvalue, numparams, 0) \
     class FunctorMember##returnvalue##numparams : public FunctorMember<T> \
     { \
 …
+    \
+    \
     FUNCTOR_TEMPLATE(1, returnvalue, numparams) \
+    FUNCTOR_TEMPLATE(1, returnvalue, numparams, 0) \
     class FunctorConstMember##returnvalue##numparams : public FunctorMember<T> \
     { \
 …
+    \
+    \
     FUNCTOR_TEMPLATE(1, returnvalue, numparams) \
+    FUNCTOR_TEMPLATE(1, returnvalue, numparams, 0) \
     inline FunctorMember##returnvalue##numparams FUNCTOR_TEMPLATE_CLASSES(1, returnvalue, numparams)* createFunctor(FUNCTOR_FUNCTION_RETURNVALUE(returnvalue) (T::*functionPointer)(FUNCTOR_FUNCTION_PARAMS(numparams))) \
     { \
 …
+    \
+    \
     FUNCTOR_TEMPLATE(1, returnvalue, numparams) \
+    FUNCTOR_TEMPLATE(1, returnvalue, numparams, 0) \
     inline FunctorConstMember##returnvalue##numparams FUNCTOR_TEMPLATE_CLASSES(1, returnvalue, numparams)* createFunctor(FUNCTOR_FUNCTION_RETURNVALUE(returnvalue) (T::*functionPointer)(FUNCTOR_FUNCTION_PARAMS(numparams)) const) \
     { \
         return new FunctorConstMember##returnvalue##numparams FUNCTOR_TEMPLATE_CLASSES(1, returnvalue, numparams) (functionPointer); \
+    } \
+    \
+    FUNCTOR_TEMPLATE(1, returnvalue, numparams, 1) \
+    inline FunctorMember##returnvalue##numparams FUNCTOR_TEMPLATE_CLASSES(1, returnvalue, numparams)* createFunctor(FUNCTOR_FUNCTION_RETURNVALUE(returnvalue) (T::*functionPointer)(FUNCTOR_FUNCTION_PARAMS(numparams)), O* object) \
+    { \
+        FunctorMember##returnvalue##numparams FUNCTOR_TEMPLATE_CLASSES(1, returnvalue, numparams)* functor = new FunctorMember##returnvalue##numparams FUNCTOR_TEMPLATE_CLASSES(1, returnvalue, numparams) (functionPointer); \
+        functor->setObject(object); \
+        return functor; \
+    } \
+    \
+    \
+    FUNCTOR_TEMPLATE(1, returnvalue, numparams, 1) \
+    inline FunctorConstMember##returnvalue##numparams FUNCTOR_TEMPLATE_CLASSES(1, returnvalue, numparams)* createFunctor(FUNCTOR_FUNCTION_RETURNVALUE(returnvalue) (T::*functionPointer)(FUNCTOR_FUNCTION_PARAMS(numparams)) const, O* object) \
+    { \
+        FunctorConstMember##returnvalue##numparams FUNCTOR_TEMPLATE_CLASSES(1, returnvalue, numparams)* functor = new FunctorConstMember##returnvalue##numparams FUNCTOR_TEMPLATE_CLASSES(1, returnvalue, numparams) (functionPointer); \
+        functor->setObject(object); \
+        return functor; \
+    }

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

-                      r5781
+                      r5929
 #endif
+#include "util/Clock.h"
 #include "util/Debug.h"
 #include "util/Exception.h"
 #include "util/OrxAssert.h"
 #include "Core.h"
-#include "Clock.h"
 #include "LuaState.h"
+#include "PathConfig.h"
 #include "Resource.h"
 …
+    {
     public:
             void logEvent(const CEGUI::String& message, CEGUI::LoggingLevel level = CEGUI::Standard)
+        void logEvent(const CEGUI::String& message, CEGUI::LoggingLevel level = CEGUI::Standard)
+        {
             int orxonoxLevel = CEGUI::Standard;
 …
         : renderWindow_(renderWindow)
         , resourceProvider_(0)
+        , camera_(NULL)
+    {
         using namespace CEGUI;
 …
         // Create our own logger to specify the filepath
         std::auto_ptr<CEGUILogger> ceguiLogger(new CEGUILogger());
         ceguiLogger->setLogFilename(Core::getLogPathString() + "cegui.log");
+        ceguiLogger->setLogFilename(PathConfig::getLogPathString() + "cegui.log");
         // set the log level according to ours (translate by subtracting 1)
         ceguiLogger->setLoggingLevel(
 …
     void GUIManager::setCamera(Ogre::Camera* camera)
+    {
+        this->camera_ = camera;
         if (camera == NULL)
             this->guiRenderer_->setTargetSceneManager(0);

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

-                      r5781
+                      r5929
         void setCamera(Ogre::Camera* camera);
+        Ogre::Camera* getCamera() { return this->camera_; }
         static GUIManager* getInstancePtr() { return singletonPtr_s; }
 …
         CEGUI::Logger*                       ceguiLogger_;      //!< CEGUI's logger to be able to log CEGUI errors in our log
         std::map<std::string, PlayerInfo*>   players_;          //!< Stores the player (owner) for each gui
+        Ogre::Camera*                        camera_;           //!< Camera used to render the scene with the GUI
         static GUIManager*                   singletonPtr_s;    //!< Singleton reference to GUIManager

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

-                      r5781
+                      r5929
 #include <boost/weak_ptr.hpp>
+#include "util/Clock.h"
 #include "util/Debug.h"
 #include "util/Exception.h"
 …
 #include "util/Sleep.h"
 #include "util/SubString.h"
-#include "Clock.h"
 #include "CommandLine.h"
 #include "ConsoleCommand.h"
 …
         { Game::getInstance().stop(); }
     SetConsoleCommandShortcutExternAlias(stop_game, "exit");
+    static void printFPS()
+        { COUT(0) << Game::getInstance().getAvgFPS() << std::endl; }
+    SetConsoleCommandShortcutExternAlias(printFPS, "printFPS");
+    static void printTickTime()
+        { COUT(0) << Game::getInstance().getAvgTickTime() << std::endl; }
+    SetConsoleCommandShortcutExternAlias(printTickTime, "printTickTime");
     std::map<std::string, GameStateInfo> Game::gameStateDeclarations_s;
 …
     Game::Game(const std::string& cmdLine)
         // Destroy factories before the Core!
         : gsFactoryDestroyer_(Game::GameStateFactory::factories_s, &std::map<std::string, shared_ptr<GameStateFactory> >::clear)
+        : gsFactoryDestroyer_(Game::GameStateFactory::getFactories(), &std::map<std::string, shared_ptr<GameStateFactory> >::clear)
+    {
         this->bAbort_ = false;
 …
                 requestedNodes.push_back(currentNode);
+            }
+            if (currentNode == NULL)
+                requestedNodes.clear();
+        }
 …
+    {
         // Split string into pieces of the form whitespacesText
         std::vector<std::pair<std::string, unsigned> > stateStrings;
+        std::vector<std::pair<std::string, int> > stateStrings;
         size_t pos = 0;
         size_t startPos = 0;
         while (pos < str.size())
+        {
             unsigned indentation = 0;
+            int indentation = 0;
             while(pos < str.size() && str[pos] == ' ')
                 ++indentation, ++pos;
 …
             stateStrings.push_back(std::make_pair(str.substr(startPos, pos - startPos), indentation));
+        }
+        unsigned int currentLevel = 0;
+        shared_ptr<GameStateTreeNode> currentNode = this->rootStateNode_;
+        for (std::vector<std::pair<std::string, unsigned> >::const_iterator it = stateStrings.begin(); it != stateStrings.end(); ++it)
+        {
+            std::string newStateName = it->first;
+            unsigned newLevel = it->second + 1; // empty root is 0
+            if (!this->checkState(newStateName))
+                ThrowException(GameState, "GameState with name '" << newStateName << "' not found!");
+            if (newStateName == this->rootStateNode_->name_)
+        if (stateStrings.empty())
+            ThrowException(GameState, "Emtpy GameState hierarchy provided, terminating.");
+        // Add element with large identation to detect the last with just an iterator
+        stateStrings.push_back(std::make_pair("", -1));
+        // Parse elements recursively
+        std::vector<std::pair<std::string, int> >::const_iterator begin = stateStrings.begin();
+        parseStates(begin, this->rootStateNode_);
+    }
+    /*** Internal ***/
+    void Game::parseStates(std::vector<std::pair<std::string, int> >::const_iterator& it, shared_ptr<GameStateTreeNode> currentNode)
+    {
+        SubString tokens(it->first, ",");
+        std::vector<std::pair<std::string, int> >::const_iterator startIt = it;
+        for (unsigned int i = 0; i < tokens.size(); ++i)
+        {
+            it = startIt; // Reset iterator to the beginning of the sub tree
+            if (!this->checkState(tokens[i]))
+                ThrowException(GameState, "GameState with name '" << tokens[i] << "' not found!");
+            if (tokens[i] == this->rootStateNode_->name_)
                 ThrowException(GameState, "You shouldn't use 'emptyRootGameState' in the hierarchy...");
+            shared_ptr<GameStateTreeNode> newNode(new GameStateTreeNode);
+            newNode->name_ = newStateName;
+            if (newLevel <= currentLevel)
+            {
+                do
+                    currentNode = currentNode->parent_.lock();
+                while (newLevel <= --currentLevel);
+            }
+            if (newLevel == currentLevel + 1)
+            {
+                // Add the child
+                newNode->parent_ = currentNode;
+                currentNode->children_.push_back(newNode);
+            }
+            else
+                ThrowException(GameState, "Indentation error while parsing the hierarchy.");
+            currentNode = newNode;
+            currentLevel = newLevel;
+        }
+    }
+    /*** Internal ***/
+            shared_ptr<GameStateTreeNode> node(new GameStateTreeNode());
+            node->name_ = tokens[i];
+            node->parent_ = currentNode;
+            currentNode->children_.push_back(node);
+            int currentLevel = it->second;
+            ++it;
+            while (it->second != -1)
+            {
+                if (it->second <= currentLevel)
+                    break;
+                else if (it->second == currentLevel + 1)
+                    parseStates(it, node);
+                else
+                    ThrowException(GameState, "Indentation error while parsing the hierarchy.");
+            }
+        }
+    }
     void Game::loadGraphics()
+    {
         if (!GameMode::bShowsGraphics_s)
+        if (!GameMode::showsGraphics())
+        {
             core_->loadGraphics();
             Loki::ScopeGuard graphicsUnloader = Loki::MakeObjGuard(*this, &Game::unloadGraphics);
-            GameMode::bShowsGraphics_s = true;
             // Construct all the GameStates that require graphics
 …
     void Game::unloadGraphics()
+    {
         if (GameMode::bShowsGraphics_s)
+        if (GameMode::showsGraphics())
+        {
             // Destroy all the GameStates that require graphics
 …
             core_->unloadGraphics();
-            GameMode::bShowsGraphics_s = false;
+        }
+    }
 …
+    }
+    std::map<std::string, shared_ptr<Game::GameStateFactory> > Game::GameStateFactory::factories_s;
+    /*static*/ std::map<std::string, shared_ptr<Game::GameStateFactory> >& Game::GameStateFactory::getFactories()
+    {
+        static std::map<std::string, shared_ptr<GameStateFactory> > factories;
+        return factories;
+    }
     /*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());
+        std::map<std::string, shared_ptr<Game::GameStateFactory> >::const_iterator it = getFactories().find(info.className);
+        assert(it != getFactories().end());
         return it->second->fabricateInternal(info);
+    }

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

-                      r5747
+                      r5929
             template <class T>
             static void createFactory(const std::string& className)
                 { factories_s[className].reset(new TemplateGameStateFactory<T>()); }
+                { getFactories()[className].reset(new TemplateGameStateFactory<T>()); }
             virtual shared_ptr<GameState> fabricateInternal(const GameStateInfo& info) = 0;
             static std::map<std::string, shared_ptr<GameStateFactory> > factories_s;
+            static std::map<std::string, shared_ptr<GameStateFactory> >& getFactories();
         };
         template <class T>
 …
         void unloadGraphics();
+        void parseStates(std::vector<std::pair<std::string, int> >::const_iterator& it, shared_ptr<GameStateTreeNode> currentNode);
         bool checkState(const std::string& name) const;
         void loadState(const std::string& name);

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

-                      r5781
+                      r5929
  */
-/**
-    @file
-    @brief Implementation of the GameMode class.
-*/
 #include "GameMode.h"
 …
+{
     bool GameMode::bShowsGraphics_s = false;
+    bool GameMode::bPlaysSound_s    = false;
     bool GameMode::bHasServer_s     = false;
     bool GameMode::bIsClient_s      = false;

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

-                      r5781
+                      r5929
     class _CoreExport GameMode
+    {
         friend class Game;
+        friend class Core;
         public:
             static bool showsGraphics() { return bShowsGraphics_s; }
+            static bool playsSound()    { return bPlaysSound_s; }
             static bool hasServer()     { return bHasServer_s; }
             static bool isClient()      { return bIsClient_s; }
 …
             static bool isMaster()      { return bIsMaster_s; }
+            static void setPlaysSound   (bool val) { bPlaysSound_s    = val; }
             static void setHasServer    (bool val) { bHasServer_s     = val; updateIsMaster(); }
             static void setIsClient     (bool val) { bIsClient_s      = val; updateIsMaster(); }
 …
             static bool bShowsGraphics_s;                   //!< global variable that tells whether to show graphics
+            static bool bPlaysSound_s;                      //!< global variable that tells whether to sound works
             static bool bHasServer_s;                       //!< global variable that tells whether this is a server
             static bool bIsClient_s;

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

r5738	r5929
40	40	#include <map>
41	41	#include <string>
	42	#include "util/UtilPrereqs.h"
42	43
43	44	namespace orxonox

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

-                      r5781
+                      r5929
 #include "SpecialConfig.h"
+#include "util/Clock.h"
 #include "util/Exception.h"
 #include "util/StringUtils.h"
 #include "util/SubString.h"
-#include "Clock.h"
 #include "ConsoleCommand.h"
 #include "ConfigValueIncludes.h"
 #include "CoreIncludes.h"
-#include "Core.h"
 #include "Game.h"
 #include "GameMode.h"
 #include "Loader.h"
 #include "MemoryArchive.h"
+#include "PathConfig.h"
 #include "WindowEventListener.h"
 #include "XMLFile.h"
 …
         // At first, add the root paths of the data directories as resource locations
         Ogre::ResourceGroupManager::getSingleton().addResourceLocation(Core::getDataPathString(), "FileSystem", "dataRoot", false);
+        Ogre::ResourceGroupManager::getSingleton().addResourceLocation(PathConfig::getDataPathString(), "FileSystem", "dataRoot", false);
         // Load resources
         resources_.reset(new XMLFile("resources.oxr", "dataRoot"));
 …
         // Only for development runs
         if (Core::isDevelopmentRun())
+        {
             Ogre::ResourceGroupManager::getSingleton().addResourceLocation(Core::getExternalDataPathString(), "FileSystem", "externalDataRoot", false);
+        if (PathConfig::isDevelopmentRun())
+        {
+            Ogre::ResourceGroupManager::getSingleton().addResourceLocation(PathConfig::getExternalDataPathString(), "FileSystem", "externalDataRoot", false);
             extResources_.reset(new XMLFile("resources.oxr", "externalDataRoot"));
             extResources_->setLuaSupport(false);
 …
     GraphicsManager::~GraphicsManager()
+    {
+        Loader::unload(debugOverlay_.get());
         Ogre::WindowEventUtilities::removeWindowEventListener(renderWindow_, ogreWindowEventListener_.get());
         // TODO: Destroy the console command
+        // Undeclare the resources
+        Loader::unload(resources_.get());
+        if (PathConfig::isDevelopmentRun())
+            Loader::unload(extResources_.get());
+    }
 …
+        }
         boost::filesystem::path ogreConfigFilepath(Core::getConfigPath() / this->ogreConfigFile_);
         boost::filesystem::path ogreLogFilepath(Core::getLogPath() / this->ogreLogFile_);
+        boost::filesystem::path ogreConfigFilepath(PathConfig::getConfigPath() / this->ogreConfigFile_);
+        boost::filesystem::path ogreLogFilepath(PathConfig::getLogPath() / this->ogreLogFile_);
         // create a new logManager
 …
         // add console commands
+        FunctorMember<GraphicsManager>* functor1 = createFunctor(&GraphicsManager::printScreen);
+        ccPrintScreen_ = createConsoleCommand(functor1->setObject(this), "printScreen");
+        ccPrintScreen_ = createConsoleCommand(createFunctor(&GraphicsManager::printScreen, this), "printScreen");
         CommandExecutor::addConsoleCommandShortcut(ccPrintScreen_);
+    }
+    void GraphicsManager::loadDebugOverlay()
+    {
+        // Load debug overlay to show info about fps and tick time
+        COUT(4) << "Loading Debug Overlay..." << std::endl;
+        debugOverlay_.reset(new XMLFile("debug.oxo"));
+        Loader::open(debugOverlay_.get());
+    }
+    /**
+    @note
+        A note about the Ogre::FrameListener: Even though we don't use them,
+        they still get called. However, the delta times are not correct (except
+        for timeSinceLastFrame, which is the most important). A little research
+        as shown that there is probably only one FrameListener that doesn't even
+        need the time. So we shouldn't run into problems.
+    */
     void GraphicsManager::update(const Clock& time)
+    {
 …
         assert(this->renderWindow_);
         this->renderWindow_->writeContentsToTimestampedFile(Core::getLogPathString() + "screenShot_", ".jpg");
+        this->renderWindow_->writeContentsToTimestampedFile(PathConfig::getLogPathString() + "screenShot_", ".jpg");
+    }
+}

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

-                      r5781
+                      r5929
         void upgradeToGraphics();
+        void loadDebugOverlay();
         bool rendererLoaded() const { return renderWindow_ != NULL; }
 …
         Ogre::Viewport*     viewport_;                 //!< default full size viewport
         // XML files for the resources
+        // XML files for the resources and the debug overlay
         shared_ptr<XMLFile> resources_;                //!< XML with resource locations
         shared_ptr<XMLFile> extResources_;             //!< XML with resource locations in the external path (only for dev runs)
+        shared_ptr<XMLFile> debugOverlay_;             //!< XML with various debug overlays
         // config values

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

-                      r5781
+                      r5929
 #include "ConfigValueContainer.h"
 #include "ConsoleCommand.h"
 #include "Factory.h"
+#include "ClassFactory.h"
 #include "XMLPort.h"
 …
         this->bSetName_ = false;
         this->factory_ = 0;
         this->bLoadable_ = true;
+        this->bLoadable_ = false;
         this->bHasConfigValues_ = false;
         this->bHasConsoleCommands_ = false;
-        this->children_ = new std::set<const Identifier*>();
-        this->directChildren_ = new std::set<const Identifier*>();
         // Default network ID is the class ID
         this->networkID_ = this->classID_;
 …
     Identifier::~Identifier()
+    {
-        delete this->children_;
-        delete this->directChildren_;
         delete this->objects_;
 …
             // There is already an entry: return it and delete the proposal
             delete proposal;
             return (*it).second;
+            return it->second;
+        }
         else
 …
+            {
                 // Tell the parent we're one of it's children
                 (*it)->getChildrenIntern().insert((*it)->getChildrenIntern().end(), this);
+                (*it)->children_.insert((*it)->children_.end(), this);
                 // Erase all parents of our parent from our direct-parent-list
 …
+            {
                 // Tell the parent we're one of it's direct children
                 (*it)->getDirectChildrenIntern().insert((*it)->getDirectChildrenIntern().end(), this);
+                (*it)->directChildren_.insert((*it)->directChildren_.end(), this);
                 // Create the super-function dependencies
 …
     /**
+        @brief Creates the class-hierarchy by creating and destroying one object of each type.
+    */
+    void Identifier::createClassHierarchy()
+    {
+        COUT(3) << "*** Identifier: Create class-hierarchy" << std::endl;
+        Identifier::startCreatingHierarchy();
+        for (std::map<std::string, Identifier*>::const_iterator it = Identifier::getStringIdentifierMap().begin(); it != Identifier::getStringIdentifierMap().end(); ++it)
+        {
+            // To create the new branch of the class-hierarchy, we create a new object and delete it afterwards.
+            if (it->second->hasFactory())
+            {
+                BaseObject* temp = it->second->fabricate(0);
+                temp->destroy();
+            }
+        }
+        Identifier::stopCreatingHierarchy();
+        COUT(3) << "*** Identifier: Finished class-hierarchy creation" << std::endl;
+    }
+    /**
         @brief Destroys all Identifiers. Called when exiting the program.
     */
 …
             this->name_ = name;
             this->bSetName_ = true;
+            Identifier::getIdentifierMapIntern()[name] = this;
+            Identifier::getLowercaseIdentifierMapIntern()[getLowercase(name)] = this;
+            Identifier::getStringIdentifierMapIntern()[name] = this;
+            Identifier::getLowercaseStringIdentifierMapIntern()[getLowercase(name)] = this;
+            Identifier::getIDIdentifierMapIntern()[this->networkID_] = this;
+        }
+    }
 …
             COUT(1) << "Aborting..." << std::endl;
             abort();
             return NULL;
+        }
+    }
     /**
         @brief Sets the network ID to a new value and changes the entry in the Factory.
+            return 0;
+        }
+    }
+    /**
+        @brief Sets the network ID to a new value and changes the entry in the ID-Identifier-map.
         @param id The new network ID
     */
     void Identifier::setNetworkID(uint32_t id)
+    {
+        Factory::changeNetworkID(this, this->networkID_, id);
+//        Identifier::getIDIdentifierMapIntern().erase(this->networkID_);
+        Identifier::getIDIdentifierMapIntern()[id] = this;
         this->networkID_ = id;
+    }
 …
     bool Identifier::isParentOf(const Identifier* identifier) const
+    {
         return (this->children_->find(identifier) != this->children_->end());
+        return (this->children_.find(identifier) != this->children_.end());
+    }
 …
     bool Identifier::isDirectParentOf(const Identifier* identifier) const
+    {
         return (this->directChildren_->find(identifier) != this->directChildren_->end());
+    }
     /**
         @brief Returns the map that stores all Identifiers.
+        return (this->directChildren_.find(identifier) != this->directChildren_.end());
+    }
+    /**
+        @brief Returns the map that stores all Identifiers with their names.
         @return The map
     */
     std::map<std::string, Identifier*>& Identifier::getIdentifierMapIntern()
+    std::map<std::string, Identifier*>& Identifier::getStringIdentifierMapIntern()
+    {
         static std::map<std::string, Identifier*> identifierMap;
 …
     /**
         @brief Returns the map that stores all Identifiers.
+        @brief Returns the map that stores all Identifiers with their names in lowercase.
         @return The map
     */
     std::map<std::string, Identifier*>& Identifier::getLowercaseIdentifierMapIntern()
+    std::map<std::string, Identifier*>& Identifier::getLowercaseStringIdentifierMapIntern()
+    {
         static std::map<std::string, Identifier*> lowercaseIdentifierMap;
         return lowercaseIdentifierMap;
+    }
+    /**
+        @brief Returns the map that stores all Identifiers with their network IDs.
+        @return The map
+    */
+    std::map<uint32_t, Identifier*>& Identifier::getIDIdentifierMapIntern()
+    {
+        static std::map<uint32_t, Identifier*> identifierMap;
+        return identifierMap;
+    }
+    /**
+        @brief Returns the Identifier with a given name.
+        @param name The name of the wanted Identifier
+        @return The Identifier
+    */
+    Identifier* Identifier::getIdentifierByString(const std::string& name)
+    {
+        std::map<std::string, Identifier*>::const_iterator it = Identifier::getStringIdentifierMapIntern().find(name);
+        if (it != Identifier::getStringIdentifierMapIntern().end())
+            return it->second;
+        else
+            return 0;
+    }
+    /**
+        @brief Returns the Identifier with a given name in lowercase.
+        @param name The name of the wanted Identifier
+        @return The Identifier
+    */
+    Identifier* Identifier::getIdentifierByLowercaseString(const std::string& name)
+    {
+        std::map<std::string, Identifier*>::const_iterator it = Identifier::getLowercaseStringIdentifierMapIntern().find(name);
+        if (it != Identifier::getLowercaseStringIdentifierMapIntern().end())
+            return it->second;
+        else
+            return 0;
+    }
+    /**
+        @brief Returns the Identifier with a given network ID.
+        @param id The network ID of the wanted Identifier
+        @return The Identifier
+    */
+    Identifier* Identifier::getIdentifierByID(const uint32_t id)
+    {
+        std::map<uint32_t, Identifier*>::const_iterator it = Identifier::getIDIdentifierMapIntern().find(id);
+        if (it != Identifier::getIDIdentifierMapIntern().end())
+            return it->second;
+        else
+            return 0;
+    }
+    /**
+        @brief Cleans the NetworkID map (needed on clients for correct initialization)
+    */
+    void Identifier::clearNetworkIDs()
+    {
+        Identifier::getIDIdentifierMapIntern().clear();
+    }
 …
         std::map<std::string, ConfigValueContainer*>::const_iterator it = configValues_.find(varname);
         if (it != configValues_.end())
             return ((*it).second);
+            return it->second;
         else
             return 0;
 …
         std::map<std::string, ConfigValueContainer*>::const_iterator it = configValues_LC_.find(varname);
         if (it != configValues_LC_.end())
             return ((*it).second);
+            return it->second;
         else
             return 0;
 …
         std::map<std::string, ConsoleCommand*>::const_iterator it = this->consoleCommands_.find(name);
         if (it != this->consoleCommands_.end())
             return (*it).second;
+            return it->second;
         else
             return 0;
 …
         std::map<std::string, ConsoleCommand*>::const_iterator it = this->consoleCommands_LC_.find(name);
         if (it != this->consoleCommands_LC_.end())
             return (*it).second;
+            return it->second;
         else
             return 0;
 …
         std::map<std::string, XMLPortParamContainer*>::const_iterator it = this->xmlportParamContainers_.find(paramname);
         if (it != this->xmlportParamContainers_.end())
             return ((*it).second);
+            return it->second;
         else
             return 0;
 …
         std::map<std::string, XMLPortObjectContainer*>::const_iterator it = this->xmlportObjectContainers_.find(sectionname);
         if (it != this->xmlportObjectContainers_.end())
             return ((*it).second);
+            return it->second;
         else
             return 0;
 …
         this->xmlportObjectContainers_[sectionname] = container;
+    }
-    /**
-        @brief Returns a XMLPortEventContainer that attaches an event to this class.
-        @param sectionname The name of the section that contains the event
-        @return The container
-    */
-    XMLPortObjectContainer* Identifier::getXMLPortEventContainer(const std::string& eventname)
+    {
-        std::map<std::string, XMLPortObjectContainer*>::const_iterator it = this->xmlportEventContainers_.find(eventname);
-        if (it != this->xmlportEventContainers_.end())
-            return ((*it).second);
-        else
-            return 0;
+    }
-    /**
-        @brief Adds a new XMLPortEventContainer that attaches an event to this class.
-        @param sectionname The name of the section that contains the event
-        @param container The container
-    */
-    void Identifier::addXMLPortEventContainer(const std::string& eventname, XMLPortObjectContainer* container)
+    {
-        std::map<std::string, XMLPortObjectContainer*>::const_iterator it = this->xmlportEventContainers_.find(eventname);
-        if (it != this->xmlportEventContainers_.end())
+        {
-            COUT(2) << "Warning: Overwriting XMLPortEventContainer in class " << this->getName() << "." << std::endl;
-            delete (it->second);
+        }
-        this->xmlportEventContainers_[eventname] = container;
+    }
 …
+    {
         for (std::set<const Identifier*>::const_iterator it = list.begin(); it != list.end(); ++it)
+            out << (*it)->getName() << " ";
+        {
+            if (it != list.begin())
+                out << " ";
+            out << (*it)->getName();
+        }
         return out;

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

-                      r5781
+                      r5929
 /**
     @file
     @brief Definition of the Identifier, ClassIdentifier and SubclassIdentifier classes, implementation of the ClassIdentifier and SubclassIdentifier classes.
+    @brief Definition of the Identifier class, definition and implementation of the ClassIdentifier class.
     The Identifier contains all needed information about the class it belongs to:
 …
     Every Identifier is in fact a ClassIdentifier, but they are derived from Identifier.
-    SubclassIdentifier is a separated class, acting like an Identifier, but has a given class.
-    You can only assign Identifiers of exactly the given class or of a derivative to a SubclassIdentifier.
 */
 …
     class _CoreExport Identifier
+    {
-        template <class T>
-        friend class SubclassIdentifier;
-        friend class Factory;
         public:
+            /** @brief Returns the name of the class the Identifier belongs to. @return The name */
+            inline const std::string& getName() const { return this->name_; }
+            void setName(const std::string& name);
+            /** @brief Returns the network ID to identify a class through the network. @return the network ID */
+            inline const uint32_t getNetworkID() const { return this->networkID_; }
+            void setNetworkID(uint32_t id);
+            /** @brief Returns the unique ID of the class */
+            FORCEINLINE unsigned int getClassID() const { return this->classID_; }
+            /** @brief Returns the list of all existing objects of this class. @return The list */
+            inline ObjectListBase* getObjects() const { return this->objects_; }
             /** @brief Sets the Factory. @param factory The factory to assign */
+            inline void addFactory(BaseFactory* factory) { this->factory_ = factory; }
+            inline void addFactory(Factory* factory) { this->factory_ = factory; }
+            /** @brief Returns true if the Identifier has a Factory. */
+            inline bool hasFactory() const { return (this->factory_ != 0); }
             BaseObject* fabricate(BaseObject* creator);
+            /** @brief Returns true if the class can be loaded through XML. */
+            inline bool isLoadable() const { return this->bLoadable_; }
+            /** @brief Set the class to be loadable through XML or not. */
+            inline void setLoadable(bool bLoadable) { this->bLoadable_ = bLoadable; }
             bool isA(const Identifier* identifier) const;
             bool isExactlyA(const Identifier* identifier) const;
 …
             bool isDirectParentOf(const Identifier* identifier) const;
+            /** @brief Returns true if the class can be loaded through XML. */
+            inline bool isLoadable() const { return this->bLoadable_; }
+            /** @brief Set the class to be loadable through XML or not. */
+            inline void setLoadable(bool bLoadable) { this->bLoadable_ = bLoadable; }
+            /** @brief Returns the list of all existing objects of this class. @return The list */
+            inline ObjectListBase* getObjects() const
+                { return this->objects_; }
+            /** @brief Returns the name of the class the Identifier belongs to. @return The name */
+            inline const std::string& getName() const { return this->name_; }
+            void setName(const std::string& name);
+            virtual void updateConfigValues(bool updateChildren = true) const = 0;
+            /////////////////////////////
+            ////// Class Hierarchy //////
+            /////////////////////////////
+            static void createClassHierarchy();
+            /** @brief Returns true, if a branch of the class-hierarchy is being created, causing all new objects to store their parents. @return The status of the class-hierarchy creation */
+            inline static bool isCreatingHierarchy() { return (hierarchyCreatingCounter_s > 0); }
             /** @brief Returns the parents of the class the Identifier belongs to. @return The list of all parents */
 …
             /** @brief Returns the children of the class the Identifier belongs to. @return The list of all children */
             inline const std::set<const Identifier*>& getChildren() const { return (*this->children_); }
+            inline const std::set<const Identifier*>& getChildren() const { return this->children_; }
             /** @brief Returns the begin-iterator of the children-list. @return The begin-iterator */
             inline std::set<const Identifier*>::const_iterator getChildrenBegin() const { return this->children_->begin(); }
+            inline std::set<const Identifier*>::const_iterator getChildrenBegin() const { return this->children_.begin(); }
             /** @brief Returns the end-iterator of the children-list. @return The end-iterator */
             inline std::set<const Identifier*>::const_iterator getChildrenEnd() const { return this->children_->end(); }
+            inline std::set<const Identifier*>::const_iterator getChildrenEnd() const { return this->children_.end(); }
             /** @brief Returns the direct parents of the class the Identifier belongs to. @return The list of all direct parents */
 …
             /** @brief Returns the direct children the class the Identifier belongs to. @return The list of all direct children */
             inline const std::set<const Identifier*>& getDirectChildren() const { return (*this->directChildren_); }
+            inline const std::set<const Identifier*>& getDirectChildren() const { return this->directChildren_; }
             /** @brief Returns the begin-iterator of the direct-children-list. @return The begin-iterator */
             inline std::set<const Identifier*>::const_iterator getDirectChildrenBegin() const { return this->directChildren_->begin(); }
+            inline std::set<const Identifier*>::const_iterator getDirectChildrenBegin() const { return this->directChildren_.begin(); }
             /** @brief Returns the end-iterator of the direct-children-list. @return The end-iterator */
+            inline std::set<const Identifier*>::const_iterator getDirectChildrenEnd() const { return this->directChildren_->end(); }
+            /** @brief Returns the map that stores all Identifiers. @return The map */
+            static inline const std::map<std::string, Identifier*>& getIdentifierMap() { return Identifier::getIdentifierMapIntern(); }
+            /** @brief Returns a const_iterator to the beginning of the map that stores all Identifiers. @return The const_iterator */
+            static inline std::map<std::string, Identifier*>::const_iterator getIdentifierMapBegin() { return Identifier::getIdentifierMap().begin(); }
+            /** @brief Returns a const_iterator to the end of the map that stores all Identifiers. @return The const_iterator */
+            static inline std::map<std::string, Identifier*>::const_iterator getIdentifierMapEnd() { return Identifier::getIdentifierMap().end(); }
+            inline std::set<const Identifier*>::const_iterator getDirectChildrenEnd() const { return this->directChildren_.end(); }
+            //////////////////////////
+            ///// Identifier Map /////
+            //////////////////////////
+            static void destroyAllIdentifiers();
+            static Identifier* getIdentifierByString(const std::string& name);
+            static Identifier* getIdentifierByLowercaseString(const std::string& name);
+            static Identifier* getIdentifierByID(uint32_t id);
+            static void clearNetworkIDs();
+            /** @brief Returns the map that stores all Identifiers with their names. @return The map */
+            static inline const std::map<std::string, Identifier*>& getStringIdentifierMap() { return Identifier::getStringIdentifierMapIntern(); }
+            /** @brief Returns a const_iterator to the beginning of the map that stores all Identifiers with their names. @return The const_iterator */
+            static inline std::map<std::string, Identifier*>::const_iterator getStringIdentifierMapBegin() { return Identifier::getStringIdentifierMap().begin(); }
+            /** @brief Returns a const_iterator to the end of the map that stores all Identifiers with their names. @return The const_iterator */
+            static inline std::map<std::string, Identifier*>::const_iterator getStringIdentifierMapEnd() { return Identifier::getStringIdentifierMap().end(); }
             /** @brief Returns the map that stores all Identifiers with their names in lowercase. @return The map */
             static inline const std::map<std::string, Identifier*>& getLowercaseIdentifierMap() { return Identifier::getLowercaseIdentifierMapIntern(); }
+            static inline const std::map<std::string, Identifier*>& getLowercaseStringIdentifierMap() { return Identifier::getLowercaseStringIdentifierMapIntern(); }
             /** @brief Returns a const_iterator to the beginning of the map that stores all Identifiers with their names in lowercase. @return The const_iterator */
             static inline std::map<std::string, Identifier*>::const_iterator getLowercaseIdentifierMapBegin() { return Identifier::getLowercaseIdentifierMap().begin(); }
+            static inline std::map<std::string, Identifier*>::const_iterator getLowercaseStringIdentifierMapBegin() { return Identifier::getLowercaseStringIdentifierMap().begin(); }
             /** @brief Returns a const_iterator to the end of the map that stores all Identifiers with their names in lowercase. @return The const_iterator */
+            static inline std::map<std::string, Identifier*>::const_iterator getLowercaseIdentifierMapEnd() { return Identifier::getLowercaseIdentifierMap().end(); }
+            static inline std::map<std::string, Identifier*>::const_iterator getLowercaseStringIdentifierMapEnd() { return Identifier::getLowercaseStringIdentifierMap().end(); }
+            /** @brief Returns the map that stores all Identifiers with their IDs. @return The map */
+            static inline const std::map<uint32_t, Identifier*>& getIDIdentifierMap() { return Identifier::getIDIdentifierMapIntern(); }
+            /** @brief Returns a const_iterator to the beginning of the map that stores all Identifiers with their IDs. @return The const_iterator */
+            static inline std::map<uint32_t, Identifier*>::const_iterator getIDIdentifierMapBegin() { return Identifier::getIDIdentifierMap().begin(); }
+            /** @brief Returns a const_iterator to the end of the map that stores all Identifiers with their IDs. @return The const_iterator */
+            static inline std::map<uint32_t, Identifier*>::const_iterator getIDIdentifierMapEnd() { return Identifier::getIDIdentifierMap().end(); }
+            /////////////////////////
+            ///// Config Values /////
+            /////////////////////////
+            virtual void updateConfigValues(bool updateChildren = true) const = 0;
+            /** @brief Returns true if this class has at least one config value. @return True if this class has at least one config value */
+            inline bool hasConfigValues() const { return this->bHasConfigValues_; }
             /** @brief Returns the map that stores all config values. @return The const_iterator */
 …
             inline std::map<std::string, ConfigValueContainer*>::const_iterator getLowercaseConfigValueMapEnd() const { return this->configValues_LC_.end(); }
+            void addConfigValueContainer(const std::string& varname, ConfigValueContainer* container);
+            ConfigValueContainer* getConfigValueContainer(const std::string& varname);
+            ConfigValueContainer* getLowercaseConfigValueContainer(const std::string& varname);
+            ////////////////////////////
+            ///// Console Commands /////
+            ////////////////////////////
+            /** @brief Returns true if this class has at least one console command. @return True if this class has at least one console command */
+            inline bool hasConsoleCommands() const { return this->bHasConsoleCommands_; }
             /** @brief Returns the map that stores all console commands. @return The const_iterator */
 …
             inline std::map<std::string, ConsoleCommand*>::const_iterator getLowercaseConsoleCommandMapEnd() const { return this->consoleCommands_LC_.end(); }
+            ConsoleCommand& addConsoleCommand(ConsoleCommand* command, bool bCreateShortcut);
+            ConsoleCommand* getConsoleCommand(const std::string& name) const;
+            ConsoleCommand* getLowercaseConsoleCommand(const std::string& name) const;
+            ///////////////////
+            ///// XMLPort /////
+            ///////////////////
             /** @brief Returns the map that stores all XMLPort params. @return The const_iterator */
             inline const std::map<std::string, XMLPortParamContainer*>& getXMLPortParamMap() const { return this->xmlportParamContainers_; }
 …
             inline std::map<std::string, XMLPortObjectContainer*>::const_iterator getXMLPortObjectMapEnd() const { return this->xmlportObjectContainers_.end(); }
-            /** @brief Returns the map that stores all XMLPort events. @return The const_iterator */
-            inline const std::map<std::string, XMLPortObjectContainer*>& getXMLPortEventMap() const { return this->xmlportEventContainers_; }
-            /** @brief Returns a const_iterator to the beginning of the map that stores all XMLPort events. @return The const_iterator */
-            inline std::map<std::string, XMLPortObjectContainer*>::const_iterator getXMLPortEventMapBegin() const { return this->xmlportEventContainers_.begin(); }
-            /** @brief Returns a const_iterator to the end of the map that stores all XMLPort events. @return The const_iterator */
-            inline std::map<std::string, XMLPortObjectContainer*>::const_iterator getXMLPortEventMapEnd() const { return this->xmlportEventContainers_.end(); }
-            /** @brief Returns true if this class has at least one config value. @return True if this class has at least one config value */
-            inline bool hasConfigValues() const { return this->bHasConfigValues_; }
-            /** @brief Returns true if this class has at least one console command. @return True if this class has at least one console command */
-            inline bool hasConsoleCommands() const { return this->bHasConsoleCommands_; }
-            /** @brief Returns true, if a branch of the class-hierarchy is being created, causing all new objects to store their parents. @return The status of the class-hierarchy creation */
-            inline static bool isCreatingHierarchy() { return (hierarchyCreatingCounter_s > 0); }
-            /** @brief Returns the network ID to identify a class through the network. @return the network ID */
-            inline const uint32_t getNetworkID() const { return this->networkID_; }
-            /** @brief Sets the network ID to a new value. @param id The new value */
-            void setNetworkID(uint32_t id);
-            /** @brief Returns the unique ID of the class */
-            FORCEINLINE unsigned int getClassID() const { return this->classID_; }
-            void addConfigValueContainer(const std::string& varname, ConfigValueContainer* container);
-            ConfigValueContainer* getConfigValueContainer(const std::string& varname);
-            ConfigValueContainer* getLowercaseConfigValueContainer(const std::string& varname);
             void addXMLPortParamContainer(const std::string& paramname, XMLPortParamContainer* container);
             XMLPortParamContainer* getXMLPortParamContainer(const std::string& paramname);
 …
             XMLPortObjectContainer* getXMLPortObjectContainer(const std::string& sectionname);
-            void addXMLPortEventContainer(const std::string& eventname, XMLPortObjectContainer* container);
-            XMLPortObjectContainer* getXMLPortEventContainer(const std::string& eventname);
-            ConsoleCommand& addConsoleCommand(ConsoleCommand* command, bool bCreateShortcut);
-            ConsoleCommand* getConsoleCommand(const std::string& name) const;
-            ConsoleCommand* getLowercaseConsoleCommand(const std::string& name) const;
-            void initializeClassHierarchy(std::set<const Identifier*>* parents, bool bRootClass);
-            static void destroyAllIdentifiers();
         protected:
 …
             virtual void createSuperFunctionCaller() const = 0;
+            /** @brief Returns the map that stores all Identifiers. @return The map */
+            static std::map<std::string, Identifier*>& getIdentifierMapIntern();
+            void initializeClassHierarchy(std::set<const Identifier*>* parents, bool bRootClass);
+            /** @brief Returns the map that stores all Identifiers with their names. @return The map */
+            static std::map<std::string, Identifier*>& getStringIdentifierMapIntern();
             /** @brief Returns the map that stores all Identifiers with their names in lowercase. @return The map */
+            static std::map<std::string, Identifier*>& getLowercaseIdentifierMapIntern();
+            static std::map<std::string, Identifier*>& getLowercaseStringIdentifierMapIntern();
+            /** @brief Returns the map that stores all Identifiers with their network IDs. @return The map */
+            static std::map<uint32_t, Identifier*>& getIDIdentifierMapIntern();
             /** @brief Returns the children of the class the Identifier belongs to. @return The list of all children */
             inline std::set<const Identifier*>& getChildrenIntern() const { return (*this->children_); }
+            inline std::set<const Identifier*>& getChildrenIntern() const { return this->children_; }
             /** @brief Returns the direct children of the class the Identifier belongs to. @return The list of all direct children */
             inline std::set<const Identifier*>& getDirectChildrenIntern() const { return (*this->directChildren_); }
+            inline std::set<const Identifier*>& getDirectChildrenIntern() const { return this->directChildren_; }
             ObjectListBase* objects_;                                      //!< The list of all objects of this class
         private:
+            /**
+                @brief Increases the hierarchyCreatingCounter_s variable, causing all new objects to store their parents.
+            */
+            inline static void startCreatingHierarchy()
+            {
+                hierarchyCreatingCounter_s++;
+                COUT(4) << "*** Identifier: Increased Hierarchy-Creating-Counter to " << hierarchyCreatingCounter_s << std::endl;
+            }
+            /**
+                @brief Decreases the hierarchyCreatingCounter_s variable, causing the objects to stop storing their parents.
+            */
+            inline static void stopCreatingHierarchy()
+            {
+                hierarchyCreatingCounter_s--;
+                COUT(4) << "*** Identifier: Decreased Hierarchy-Creating-Counter to " << hierarchyCreatingCounter_s << std::endl;
+            }
+            /** @brief Increases the hierarchyCreatingCounter_s variable, causing all new objects to store their parents. */
+            inline static void startCreatingHierarchy() { hierarchyCreatingCounter_s++; }
+            /** @brief Decreases the hierarchyCreatingCounter_s variable, causing the objects to stop storing their parents. */
+            inline static void stopCreatingHierarchy()  { hierarchyCreatingCounter_s--; }
             static std::map<std::string, Identifier*>& getTypeIDIdentifierMap();
 …
             std::set<const Identifier*> parents_;                          //!< The parents of the class the Identifier belongs to
             std::set<const Identifier*>* children_;                        //!< The children of the class the Identifier belongs to
+            mutable std::set<const Identifier*> children_;                 //!< The children of the class the Identifier belongs to
             std::set<const Identifier*> directParents_;                    //!< The direct parents of the class the Identifier belongs to
             std::set<const Identifier*>* directChildren_;                  //!< The direct children of the class the Identifier belongs to
+            mutable std::set<const Identifier*> directChildren_;           //!< The direct children of the class the Identifier belongs to
             bool bCreatedOneObject_;                                       //!< True if at least one object of the given type was created (used to determine the need of storing the parents)
 …
             bool bLoadable_;                                               //!< False = it's not permitted to load the object through XML
             std::string name_;                                             //!< The name of the class the Identifier belongs to
             BaseFactory* factory_;                                         //!< The Factory, able to create new objects of the given class (if available)
+            Factory* factory_;                                             //!< The Factory, able to create new objects of the given class (if available)
             static int hierarchyCreatingCounter_s;                         //!< Bigger than zero if at least one Identifier stores its parents (its an int instead of a bool to avoid conflicts with multithreading)
             uint32_t networkID_;                                           //!< The network ID to identify a class through the network
 …
             std::map<std::string, XMLPortParamContainer*> xmlportParamContainers_;     //!< All loadable parameters
             std::map<std::string, XMLPortObjectContainer*> xmlportObjectContainers_;   //!< All attachable objects
-            std::map<std::string, XMLPortObjectContainer*> xmlportEventContainers_;    //!< All events
     };
 …
         public:
             static ClassIdentifier<T> *getIdentifier();
             static ClassIdentifier<T> *getIdentifier(const std::string& name);
+            static ClassIdentifier<T>* getIdentifier();
+            static ClassIdentifier<T>* getIdentifier(const std::string& name);
             bool initialiseObject(T* object, const std::string& className, bool bRootClass);
 …
     inline ClassIdentifier<T>* ClassIdentifier<T>::getIdentifier()
+    {
         // check if the static field has already been filled
         if (ClassIdentifier<T>::classIdentifier_s == 0)
+        // check if the Identifier already exists
+        if (!ClassIdentifier<T>::classIdentifier_s)
             ClassIdentifier<T>::initialiseIdentifier();
 …
 #endif
+    }
-    // ###############################
-    // ###   SubclassIdentifier    ###
-    // ###############################
-    //! The SubclassIdentifier acts almost like an Identifier, but has some prerequisites.
-    /**
-        You can only assign an Identifier that belongs to a class T (or derived) to a SubclassIdentifier<T>.
-        If you assign something else, the program aborts.
-        Because we know the minimum type, a dynamic_cast is done, which makes it easier to create a new object.
-    */
-    template <class T>
-    class SubclassIdentifier
+    {
-        public:
-            /**
-                @brief Constructor: Automaticaly assigns the Identifier of the given class.
-            */
-            SubclassIdentifier()
+            {
-                this->identifier_ = ClassIdentifier<T>::getIdentifier();
+            }
-            /**
-                @brief Copyconstructor: Assigns the given Identifier.
-                @param identifier The Identifier
-            */
-            SubclassIdentifier(Identifier* identifier)
+            {
-                this->operator=(identifier);
+            }
-            /**
-                @brief Overloading of the = operator: assigns the identifier and checks its type.
-                @param identifier The Identifier to assign
-                @return The SubclassIdentifier itself
-            */
-            SubclassIdentifier<T>& operator=(Identifier* identifier)
+            {
-                if (!identifier || !identifier->isA(ClassIdentifier<T>::getIdentifier()))
+                {
-                    COUT(1) << "An error occurred in SubclassIdentifier (Identifier.h):" << std::endl;
-                    if (identifier)
+                    {
-                        COUT(1) << "Error: Class " << identifier->getName() << " is not a " << ClassIdentifier<T>::getIdentifier()->getName() << "!" << std::endl;
-                        COUT(1) << "Error: SubclassIdentifier<" << ClassIdentifier<T>::getIdentifier()->getName() << "> = Class(" << identifier->getName() << ") is forbidden." << std::endl;
+                    }
-                    else
+                    {
-                        COUT(1) << "Error: Can't assign NULL identifier" << std::endl;
+                    }
+                }
-                else
+                {
-                    this->identifier_ = identifier;
+                }
-                return *this;
+            }
-            /**
-                @brief Overloading of the * operator: returns the assigned identifier.
-            */
-            inline Identifier* operator*() const
+            {
-                return this->identifier_;
+            }
-            /**
-                @brief Overloading of the -> operator: returns the assigned identifier.
-            */
-            inline Identifier* operator->() const
+            {
-                return this->identifier_;
+            }
-            /**
-                @brief Returns the assigned identifier. This allows you to assign a SubclassIdentifier to a normal Identifier*.
-            */
-            inline operator Identifier*() const
+            {
-                return this->identifier_;
+            }
-            /**
-                @brief Creates a new object of the type of the assigned Identifier and dynamic_casts it to the minimal type given by T.
-                @return The new object
-            */
-            T* fabricate(BaseObject* creator) const
+            {
-                BaseObject* newObject = this->identifier_->fabricate(creator);
-                // Check if the creation was successful
-                if (newObject)
+                {
-                    return orxonox_cast<T*>(newObject);
+                }
-                else
+                {
-                    // Something went terribly wrong
-                    if (this->identifier_)
+                    {
-                        COUT(1) << "An error occurred in SubclassIdentifier (Identifier.h):" << std::endl;
-                        COUT(1) << "Error: Class " << this->identifier_->getName() << " is not a " << ClassIdentifier<T>::getIdentifier()->getName() << "!" << std::endl;
-                        COUT(1) << "Error: Couldn't fabricate a new Object." << std::endl;
-                        COUT(1) << "Aborting..." << std::endl;
+                    }
-                    else
+                    {
-                        COUT(1) << "An error occurred in SubclassIdentifier (Identifier.h):" << std::endl;
-                        COUT(1) << "Error: Couldn't fabricate a new Object - Identifier is undefined." << std::endl;
-                        COUT(1) << "Aborting..." << std::endl;
+                    }
-                    assert(false);
-                    return 0;
+                }
+            }
-            /** @brief Returns the assigned identifier. @return The identifier */
-            inline Identifier* getIdentifier() const
-                { return this->identifier_; }
-//            /** @brief Returns true, if the assigned identifier is at least of the given type. @param identifier The identifier to compare with */
-//            inline bool isA(const Identifier* identifier) const
-//                { return this->identifier_->isA(identifier); }
-//
-//            /** @brief Returns true, if the assigned identifier is exactly of the given type. @param identifier The identifier to compare with */
-//            inline bool isExactlyA(const Identifier* identifier) const
-//                { return this->identifier_->isExactlyA(identifier); }
-//
-//            /** @brief Returns true, if the assigned identifier is a child of the given identifier. @param identifier The identifier to compare with */
-//            inline bool isChildOf(const Identifier* identifier) const
-//                { return this->identifier_->isChildOf(identifier); }
-//
-//            /** @brief Returns true, if the assigned identifier is a direct child of the given identifier. @param identifier The identifier to compare with */
-//            inline bool isDirectChildOf(const Identifier* identifier) const
-//                { return this->identifier_->isDirectChildOf(identifier); }
-//
-//            /** @brief Returns true, if the assigned identifier is a parent of the given identifier. @param identifier The identifier to compare with */
-//            inline bool isParentOf(const Identifier* identifier) const
-//                { return this->identifier_->isParentOf(identifier); }
-//
-//            /** @brief Returns true, if the assigned identifier is a direct parent of the given identifier. @param identifier The identifier to compare with */
-//            inline bool isDirectParentOf(const Identifier* identifier) const
-//                { return this->identifier_->isDirectParentOf(identifier); }
-        private:
-            Identifier* identifier_;            //!< The assigned identifier
-    };
+}

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

r5738	r5929
167	167
168	168	return (*this);
169		~~return *this;~~
170	169	}
171	170
…	…
193	192	inline const Iterator<T>& operator++()
194	193	{
195		if (this->element_)
196		this->element_ = this->element_->next_;
	194	this->element_ = this->element_->next_;
197	195	return *this;
198	196	}
…	…
205	203	{
206	204	Iterator<T> copy = *this;
207		if (this->element_)
208		this->element_ = this->element_->next_;
	205	this->element_ = this->element_->next_;
209	206	return copy;
210	207	}
…	…
216	213	inline const Iterator<T>& operator--()
217	214	{
218		if (this->element_)
219		this->element_ = this->element_->prev_;
	215	this->element_ = this->element_->prev_;
220	216	return *this;
221	217	}
…	…
228	224	{
229	225	Iterator<T> copy = *this;
230		if (this->element_)
231		this->element_ = this->element_->prev_;
	226	this->element_ = this->element_->prev_;
232	227	return copy;
233	228	}
…	…
239	234	inline T* operator*() const
240	235	{
241		if (this->element_)
242		return orxonox_cast<T*>(this->element_->objectBase_);
243		else
244		return 0;
	236	return orxonox_cast<T*>(this->element_->objectBase_);
245	237	}
246	238
…	…
251	243	inline T* operator->() const
252	244	{
253		if (this->element_)
254		return orxonox_cast<T*>(this->element_->objectBase_);
255		else
256		return 0;
	245	return orxonox_cast<T*>(this->element_->objectBase_);
257	246	}
258	247

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

-                      r5738
+                      r5929
 #include <fstream>
-#include <boost/filesystem.hpp>
 #include "util/Debug.h"
 #include "Core.h"
+#include "PathConfig.h"
 namespace orxonox
 …
         COUT(4) << "Read default language file." << std::endl;
         boost::filesystem::path filepath(Core::getConfigPath() / getFilename(this->defaultLanguage_));
+        std::string filepath = PathConfig::getConfigPathString() + getFilename(this->defaultLanguage_);
         // This creates the file if it's not existing
         std::ofstream createFile;
         createFile.open(filepath.string().c_str(), std::fstream::app);
+        createFile.open(filepath.c_str(), std::fstream::app);
         createFile.close();
         // Open the file
         std::ifstream file;
         file.open(filepath.string().c_str(), std::fstream::in);
+        file.open(filepath.c_str(), std::fstream::in);
         if (!file.is_open())
 …
         COUT(4) << "Read translated language file (" << Core::getLanguage() << ")." << std::endl;
         boost::filesystem::path filepath(Core::getConfigPath() / getFilename(Core::getLanguage()));
+        std::string filepath = PathConfig::getConfigPathString() + getFilename(Core::getLanguage());
         // Open the file
         std::ifstream file;
         file.open(filepath.string().c_str(), std::fstream::in);
+        file.open(filepath.c_str(), std::fstream::in);
         if (!file.is_open())
 …
         COUT(4) << "Language: Write default language file." << std::endl;
         boost::filesystem::path filepath(Core::getConfigPath() / getFilename(this->defaultLanguage_));
+        std::string filepath = PathConfig::getConfigPathString() + getFilename(this->defaultLanguage_);
         // Open the file
         std::ofstream file;
         file.open(filepath.string().c_str(), std::fstream::out);
+        file.open(filepath.c_str(), std::fstream::out);
         if (!file.is_open())

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

-                      r5781
+                      r5929
+        {
             if (mask.isIncluded(it->getIdentifier()))
                 delete (*(it++));
+                (it++)->destroy();
             else
                 ++it;
 …
+        {
             if ((it->getFile() == file) && mask.isIncluded(it->getIdentifier()))
                 delete (*(it++));
+                (it++)->destroy();
             else
                 ++it;

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

r5781	r5929
37	37
38	38	#include "util/Debug.h"
39		~~#include "Core.h"~~
40	39	#include "Resource.h"
41	40	#include "ToluaBindCore.h"

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

-                      r5781
+                      r5929
                 continue;
             if (bDirs)
                 file = file.parent_path();
+                file = file.branch_path();
             if (file.empty())
                 continue;
             if (file.has_parent_path() && !bRecursive)
+            if (file.has_branch_path() && !bRecursive)
                 continue;
             if (simpleList)
 …
                 fi.archive = this;
                 fi.filename = file.string();
                 fi.basename = file.filename();
                 fi.path = file.parent_path().string();
+                fi.basename = file.leaf();
+                fi.path = file.branch_path().string();
                 fi.compressedSize = it->second.second;
                 fi.uncompressedSize = it->second.second;
 …
     bool MemoryArchive::exists(const String& filename)
+        {
+    {
         const FileMap& files = archives_s[this->getName()];
         return files.find(filename) != files.end();
+        }
+    }
     const Ogre::String& MemoryArchiveFactory::getType(void) const

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

r5738	r5929
123	123	inline const ObjectListIterator<T>& operator++()
124	124	{
125		if (this->element_)
126		this->element_ = static_cast<ObjectListElement<T>*>(this->element_->next_);
	125	this->element_ = static_cast<ObjectListElement<T>*>(this->element_->next_);
127	126	return *this;
128	127	}
…	…
135	134	{
136	135	ObjectListIterator<T> copy = *this;
137		if (this->element_)
138		this->element_ = static_cast<ObjectListElement<T>*>(this->element_->next_);
	136	this->element_ = static_cast<ObjectListElement<T>*>(this->element_->next_);
139	137	return copy;
140	138	}
…	…
146	144	inline const ObjectListIterator<T>& operator--()
147	145	{
148		if (this->element_)
149		this->element_ = static_cast<ObjectListElement<T>*>(this->element_->prev_);
	146	this->element_ = static_cast<ObjectListElement<T>*>(this->element_->prev_);
150	147	return *this;
151	148	}
…	…
158	155	{
159	156	ObjectListIterator<T> copy = *this;
160		if (this->element_)
161		this->element_ = static_cast<ObjectListElement<T>*>(this->element_->prev_);
	157	this->element_ = static_cast<ObjectListElement<T>*>(this->element_->prev_);
162	158	return copy;
163	159	}
…	…
169	165	inline T* operator*() const
170	166	{
171		if (this->element_)
172		return this->element_->object_;
173		else
174		return 0;
	167	return this->element_->object_;
175	168	}
176	169
…	…
181	174	inline T* operator->() const
182	175	{
183		if (this->element_)
184		return this->element_->object_;
185		else
186		return 0;
	176	return this->element_->object_;
187	177	}
188	178

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

-                      r5738
+                      r5929
 #include "MetaObjectList.h"
 #include "Identifier.h"
+#include "WeakPtr.h"
 namespace orxonox
 …
         this->parents_ = 0;
         this->metaList_ = new MetaObjectList();
+        this->referenceCount_ = 0;
+        this->requestedDestruction_ = false;
+    }
 …
     OrxonoxClass::~OrxonoxClass()
+    {
+//        if (!this->requestedDestruction_)
+//            COUT(2) << "Warning: Destroyed object without destroy() (" << this->getIdentifier()->getName() << ")" << std::endl;
+        assert(this->referenceCount_ <= 0);
         delete this->metaList_;
 …
         if (this->parents_)
             delete this->parents_;
+        // reset all weak pointers pointing to this object
+        for (std::set<WeakPtr<OrxonoxClass>*>::iterator it = this->weakPointers_.begin(); it != this->weakPointers_.end(); )
+            (*(it++))->objectDeleted();
+    }
+    /** @brief Deletes the object if no smart pointers point to this object. Otherwise schedules the object to be deleted as soon as possible. */
+    void OrxonoxClass::destroy()
+    {
+        this->requestedDestruction_ = true;
+        if (this->referenceCount_ == 0)
+            delete this;
+    }
 …
     /** @brief Returns true if the objects class is of the given type or a derivative. */
-    template <class B> bool OrxonoxClass::isA(const SubclassIdentifier<B>* identifier)
-        { return this->getIdentifier()->isA(identifier->getIdentifier()); }
-    /** @brief Returns true if the objects class is exactly of the given type. */
-    template <class B> bool OrxonoxClass::isExactlyA(const SubclassIdentifier<B>* identifier)
-        { return this->getIdentifier()->isExactlyA(identifier->getIdentifier()); }
-    /** @brief Returns true if the objects class is a child of the given type. */
-    template <class B> bool OrxonoxClass::isChildOf(const SubclassIdentifier<B>* identifier)
-        { return this->getIdentifier()->isChildOf(identifier->getIdentifier()); }
-    /** @brief Returns true if the objects class is a direct child of the given type. */
-    template <class B> bool OrxonoxClass::isDirectChildOf(const SubclassIdentifier<B>* identifier)
-        { return this->getIdentifier()->isDirectChildOf(identifier->getIdentifier()); }
-    /** @brief Returns true if the objects class is a parent of the given type. */
-    template <class B> bool OrxonoxClass::isParentOf(const SubclassIdentifier<B>* identifier)
-        { return this->getIdentifier()->isParentOf(identifier->getIdentifier()); }
-    /** @brief Returns true if the objects class is a direct parent of the given type. */
-    template <class B> bool OrxonoxClass::isDirectParentOf(const SubclassIdentifier<B>* identifier)
-        { return this->getIdentifier()->isDirectParentOf(identifier->getIdentifier()); }
-    /** @brief Returns true if the objects class is of the given type or a derivative. */
-    template <class B> bool OrxonoxClass::isA(const SubclassIdentifier<B> identifier)
-        { return this->getIdentifier()->isA(identifier.getIdentifier()); }
-    /** @brief Returns true if the objects class is exactly of the given type. */
-    template <class B> bool OrxonoxClass::isExactlyA(const SubclassIdentifier<B> identifier)
-        { return this->getIdentifier()->isExactlyA(identifier.getIdentifier()); }
-    /** @brief Returns true if the objects class is a child of the given type. */
-    template <class B> bool OrxonoxClass::isChildOf(const SubclassIdentifier<B> identifier)
-        { return this->getIdentifier()->isChildOf(identifier.getIdentifier()); }
-    /** @brief Returns true if the objects class is a direct child of the given type. */
-    template <class B> bool OrxonoxClass::isDirectChildOf(const SubclassIdentifier<B> identifier)
-        { return this->getIdentifier()->isDirectChildOf(identifier.getIdentifier()); }
-    /** @brief Returns true if the objects class is a parent of the given type. */
-    template <class B> bool OrxonoxClass::isParentOf(const SubclassIdentifier<B> identifier)
-        { return this->getIdentifier()->isParentOf(identifier.getIdentifier()); }
-    /** @brief Returns true if the objects class is a direct parent of the given type. */
-    template <class B> bool OrxonoxClass::isDirectParentOf(const SubclassIdentifier<B> identifier)
-        { return this->getIdentifier()->isDirectParentOf(identifier.getIdentifier()); }
-    /** @brief Returns true if the objects class is of the given type or a derivative. */
     bool OrxonoxClass::isA(const OrxonoxClass* object)
         { return this->getIdentifier()->isA(object->getIdentifier()); }

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

-                      r5738
+                      r5929
         friend class ClassIdentifier;
+        template <class T>
+        friend class SmartPtr;
+        template <class T>
+        friend class WeakPtr;
         public:
             OrxonoxClass();
             virtual ~OrxonoxClass();
+            void destroy();
             /** @brief Function to collect the SetConfigValue-macro calls. */
 …
             bool isDirectParentOf(const Identifier* identifier);
+            template <class B> bool isA(const SubclassIdentifier<B>* identifier);
+            template <class B> bool isExactlyA(const SubclassIdentifier<B>* identifier);
+            template <class B> bool isChildOf(const SubclassIdentifier<B>* identifier);
+            template <class B> bool isDirectChildOf(const SubclassIdentifier<B>* identifier);
+            template <class B> bool isParentOf(const SubclassIdentifier<B>* identifier);
+            template <class B> bool isDirectParentOf(const SubclassIdentifier<B>* identifier);
+            template <class B> bool isA(const SubclassIdentifier<B> identifier);
+            template <class B> bool isExactlyA(const SubclassIdentifier<B> identifier);
+            template <class B> bool isChildOf(const SubclassIdentifier<B> identifier);
+            template <class B> bool isDirectChildOf(const SubclassIdentifier<B> identifier);
+            template <class B> bool isParentOf(const SubclassIdentifier<B> identifier);
+            template <class B> bool isDirectParentOf(const SubclassIdentifier<B> identifier);
+            template <class B> inline bool isA(const SubclassIdentifier<B>* identifier)
+                { return this->isA(*identifier); }
+            template <class B> inline bool isExactlyA(const SubclassIdentifier<B>* identifier)
+                { return this->isExactlyA(*identifier); }
+            template <class B> inline bool isChildOf(const SubclassIdentifier<B>* identifier)
+                { return this->isChildOf(*identifier); }
+            template <class B> inline bool isDirectChildOf(const SubclassIdentifier<B>* identifier)
+                { return this->isDirectChildOf(*identifier); }
+            template <class B> inline bool isParentOf(const SubclassIdentifier<B>* identifier)
+                { return this->isParentOf(*identifier); }
+            template <class B> inline bool isDirectParentOf(const SubclassIdentifier<B>* identifier)
+                { return this->isDirectParentOf(*identifier); }
             bool isA(const OrxonoxClass* object);
 …
             bool isDirectParentOf(const OrxonoxClass* object);
+            inline unsigned int getReferenceCount() const
+                { return this->referenceCount_; }
             /**
             @brief
 …
                 Returns NULL if the no pointer was found.
             */
+            template <class T>
+            FORCEINLINE T* getDerivedPointer(unsigned int classID)
+            FORCEINLINE void* getDerivedPointer(unsigned int classID)
+            {
                 for (int i = this->objectPointers_.size() - 1; i >= 0; --i)
+                {
                     if (this->objectPointers_[i].first == classID)
                         return static_cast<T*>(this->objectPointers_[i].second);
+                        return this->objectPointers_[i].second;
+                }
                 return NULL;
+            }
+            //! Const version of getDerivedPointer
+            template <class T>
+            FORCEINLINE const T* getDerivedPointer(unsigned int classID) const
+            {
+                return const_cast<OrxonoxClass*>(this)->getDerivedPointer<T>(classID);
+            }
+            //! Version of getDerivedPointer with template
+            template <class T> FORCEINLINE T* getDerivedPointer(unsigned int classID)
+            {   return static_cast<T*>(this->getDerivedPointer(classID));   }
+            //! Const version of getDerivedPointer with template
+            template <class T> FORCEINLINE const T* getDerivedPointer(unsigned int classID) const
+            {   return const_cast<OrxonoxClass*>(this)->getDerivedPointer<T>(classID);   }
         private:
+            /** @brief Increments the reference counter (for smart pointers). */
+            inline void incrementReferenceCount()
+                { ++this->referenceCount_; }
+            /** @brief Decrements the reference counter (for smart pointers). */
+            inline void decrementReferenceCount()
+                { --this->referenceCount_; if (this->referenceCount_ == 0 && this->requestedDestruction_) { delete this; } }
+            /** @brief Register a weak pointer which points to this object. */
+            template <class T>
+            inline void registerWeakPtr(WeakPtr<T>* pointer)
+                { this->weakPointers_.insert(reinterpret_cast<WeakPtr<OrxonoxClass>*>(pointer)); }
+            /** @brief Unegister a weak pointer which pointed to this object before. */
+            template <class T>
+            inline void unregisterWeakPtr(WeakPtr<T>* pointer)
+                { this->weakPointers_.erase(reinterpret_cast<WeakPtr<OrxonoxClass>*>(pointer)); }
             Identifier* identifier_;                   //!< The Identifier of the object
             std::set<const Identifier*>* parents_;     //!< List of all parents of the object
             MetaObjectList* metaList_;                 //!< MetaObjectList, containing all ObjectLists and ObjectListElements the object is registered in
+            int referenceCount_;                       //!< Counts the references from smart pointers to this object
+            bool requestedDestruction_;                //!< Becomes true after someone called delete on this object
+            std::set<WeakPtr<OrxonoxClass>*> weakPointers_; //!< All weak pointers which point to this object (and like to get notified if it dies)
             //! 'Fast map' that holds this-pointers of all derived types
             std::vector<std::pair<unsigned int, void*> > objectPointers_;

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

-                      r5781
+                      r5929
         // Docs by Ogre::ResourceGroupManager.h
     public:
                 /**
+        /**
         @brief
             Open a single resource by name and return a DataStream
 …
             Shared pointer to data stream containing the data. Will be
             destroyed automatically when no longer referenced.
                 */
+        */
         static DataStreamPtr open(const std::string& name,
             const std::string& group = Resource::DEFAULT_GROUP,
             bool bSearchGroupsIfNotFound = false);
                 /**
+        /**
         @brief
             Open all resources matching a given pattern (which can contain
 …
             Shared pointer to a data stream list , will be
             destroyed automatically when no longer referenced
                 */
+        */
         static DataStreamListPtr openMulti(const std::string& pattern, const std::string& group = Resource::DEFAULT_GROUP);

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

r5781	r5929
88	88	OutputHandler::getOutStream().setOutputBuffer(0);
89	89	if (this->inputBuffer_)
90		~~delete this->inputBuffer_~~;
	90	this->inputBuffer_->destroy();
91	91	}
92	92

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

-                      r5781
+                      r5929
         SUPER_NOARGS(classname, functionname)
     #define SUPER_processEvent(classname, functionname, ...) \
+    #define SUPER_XMLEventPort(classname, functionname, ...) \
         SUPER_ARGS(classname, functionname, __VA_ARGS__)
     #define SUPER_changedScale(classname, functionname, ...) \
-        SUPER_NOARGS(classname, functionname)
-    #define SUPER_changedMainState(classname, functionname, ...) \
         SUPER_NOARGS(classname, functionname)
 …
         SUPER_FUNCTION_GLOBAL_DECLARATION_PART2;
         SUPER_FUNCTION_GLOBAL_DECLARATION_PART1(4, processEvent, true, Event& event)
             (event)
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART1(4, XMLEventPort, true, Element& xmlelement, XMLPort::Mode mode)
+            (xmlelement, mode)
         SUPER_FUNCTION_GLOBAL_DECLARATION_PART2;
 …
         SUPER_FUNCTION_GLOBAL_DECLARATION_PART2;
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART1(6, changedMainState, false)
+            ()
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART2;
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART1(7, changedOwner, false)
+            ()
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART2;
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART1(8, changedOverlayGroup, false)
+            ()
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART2;
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART1(9, changedName, false)
+            ()
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART2;
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART1(10, changedGametype, false)
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART1(6, changedOwner, false)
+            ()
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART2;
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART1(7, changedOverlayGroup, false)
+            ()
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART2;
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART1(8, changedName, false)
+            ()
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART2;
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART1(9, changedGametype, false)
             ()
         SUPER_FUNCTION_GLOBAL_DECLARATION_PART2;
 …
     SUPER_INTRUSIVE_DECLARATION(changedActivity);
     SUPER_INTRUSIVE_DECLARATION(changedVisibility);
     SUPER_INTRUSIVE_DECLARATION(processEvent);
+    SUPER_INTRUSIVE_DECLARATION(XMLEventPort);
     SUPER_INTRUSIVE_DECLARATION(changedScale);
-    SUPER_INTRUSIVE_DECLARATION(changedMainState);
     SUPER_INTRUSIVE_DECLARATION(changedOwner);
     SUPER_INTRUSIVE_DECLARATION(changedOverlayGroup);

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

-                      r5781
+                      r5929
 #include "CommandExecutor.h"
 #include "ConsoleCommand.h"
 #include "Core.h"
+#include "PathConfig.h"
 #include "TclThreadManager.h"
 …
+    {
 #ifdef DEPENDENCY_PACKAGE_ENABLE
         if (Core::isDevelopmentRun())
+        if (PathConfig::isDevelopmentRun())
             return (std::string(specialConfig::dependencyLibraryDirectory) + "/tcl");
         else
             return (Core::getRootPathString() + "lib/tcl");
+            return (PathConfig::getRootPathString() + "lib/tcl");
 #else
         return "";

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

-                      r5781
+                      r5929
 #include <cpptcl/cpptcl.h>
+#include "util/Clock.h"
 #include "util/Convert.h"
 #include "util/Exception.h"
-#include "Clock.h"
 #include "CommandExecutor.h"
 #include "ConsoleCommand.h"

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

r5781	r5929
51	51	#include "util/MultiType.h"
52	52	#include "util/OrxAssert.h"
53		~~#include "Factory.h"~~
54	53	#include "Identifier.h"
55	54	#include "Executor.h"
…	…
377	376	this->owner_->xmlAttributes_.clear();
378	377	// Iterate through the attributes manually in order to make them case insensitive
379		Attribute* attribute = xmlelement.FirstAttribute(false);
	378	ticpp::Attribute* attribute = xmlelement.FirstAttribute(false);
380	379	while (attribute != 0)
381	380	{
…	…
412	411	}
413	412	}
414		else
	413	else if (mode == XMLPort::SaveObject)
415	414	{
416	415	if (this->saveexecutor_)
…	…
548	547	for (ticpp::Iterator<ticpp::Element> child = xmlsubelement->FirstChildElement(false); child != child.end(); child++)
549	548	{
550		Identifier* identifier = ~~Factory::getIdentifier~~(child->Value());
	549	Identifier* identifier = Identifier::getIdentifierByString(child->Value());
551	550	if (identifier)
552	551	{
…	…
629	628	}
630	629	}
631		else
	630	else if (mode == XMLPort::SaveObject)
632	631	{
633	632	}

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

-                      r5781
+                      r5929
                 // evaluate the command
                 CommandEvaluation eval = CommandExecutor::evaluate(commandStr);
+                const CommandEvaluation& eval = CommandExecutor::evaluate(commandStr);
                 if (!eval.isValid())
+                {
                     parseError("Command evaluation failed.", true);
+                    parseError("Command evaluation of \"" + commandStr + "\"failed.", true);
                     continue;
+                }

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

r5781	r5929
9	9	JoyStickQuantityListener.cc
10	10	KeyBinder.cc
	11	KeyBinderManager.cc
11	12	Keyboard.cc
12	13	KeyDetector.cc

code/trunk/src/libraries/core/input/InputDevice.h

-                      r5781
+                      r5929
 #include <ois/OISInputManager.h>
+#include "util/Clock.h"
 #include "util/Debug.h"
 #include "util/Exception.h"
-#include "core/Clock.h"
 #include "InputState.h"

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

-                      r5781
+                      r5929
 #include <boost/foreach.hpp>
+#include "util/Clock.h"
 #include "util/Convert.h"
 #include "util/Exception.h"
 #include "util/ScopeGuard.h"
-#include "core/Clock.h"
 #include "core/CoreIncludes.h"
 #include "core/ConfigValueIncludes.h"
 …
 #include "InputBuffer.h"
-#include "KeyDetector.h"
 #include "JoyStick.h"
 #include "JoyStickQuantityListener.h"
 …
         , oisInputManager_(0)
         , devices_(2)
         , bExclusiveMouse_(false)
+        , mouseMode_(MouseMode::Nonexclusive)
         , emptyState_(0)
-        , keyDetector_(0)
         , calibratorCallbackHandler_(0)
+    {
 …
         this->setConfigValues();
+        if (GraphicsManager::getInstance().isFullScreen())
+            mouseMode_ = MouseMode::Exclusive;
         this->loadDevices();
 …
         emptyState_->setHandler(&InputHandler::EMPTY);
         activeStates_[emptyState_->getPriority()] = emptyState_;
-        // KeyDetector to evaluate a pressed key's name
-        InputState* detector = createInputState("detector", false, false, InputStatePriority::Detector);
-        // Create a callback to avoid buttonHeld events after the key has been detected
-        FunctorMember<InputManager>* bufferFunctor = createFunctor(&InputManager::clearBuffers);
-        bufferFunctor->setObject(this);
-        detector->setLeaveFunctor(bufferFunctor);
-        keyDetector_ = new KeyDetector();
-        detector->setHandler(keyDetector_);
         // Joy stick calibration helper callback
 …
         this->updateActiveStates();
+        {
+            // calibrate console command
+            FunctorMember<InputManager>* functor = createFunctor(&InputManager::calibrate);
+            functor->setObject(this);
+            this->getIdentifier()->addConsoleCommand(createConsoleCommand(functor, "calibrate"), true);
+        }
+        {
+            // reload console command
+            FunctorMember<InputManager>* functor = createFunctor(&InputManager::reload);
+            functor->setObject(this);
+            this->getIdentifier()->addConsoleCommand(createConsoleCommand(functor, "reload"), false);
+        }
+        // calibrate console command
+        this->getIdentifier()->addConsoleCommand(createConsoleCommand(createFunctor(&InputManager::calibrate, this), "calibrate"), true);
+        // reload console command
+        this->getIdentifier()->addConsoleCommand(createConsoleCommand(createFunctor(&InputManager::reload, this), "reload"), false);
         CCOUT(4) << "Construction complete." << std::endl;
 …
         paramList.insert(std::make_pair("w32_keyboard", "DISCL_FOREGROUND"));
         paramList.insert(std::make_pair("w32_mouse", "DISCL_FOREGROUND"));
         if (bExclusiveMouse_ || GraphicsManager::getInstance().isFullScreen())
+        if (mouseMode_ == MouseMode::Exclusive || GraphicsManager::getInstance().isFullScreen())
+        {
             // Disable Windows key plus special keys (like play, stop, next, etc.)
 …
         paramList.insert(std::make_pair("XAutoRepeatOn", "true"));
         if (bExclusiveMouse_ || GraphicsManager::getInstance().isFullScreen())
+        if (mouseMode_ == MouseMode::Exclusive || GraphicsManager::getInstance().isFullScreen())
+        {
             if (CommandLine::getValue("keyboard_no_grab").getBool())
 …
+    }
-    void InputManager::setKeyDetectorCallback(const std::string& command)
+    {
-        this->keyDetector_->setCallbackCommand(command);
+    }
     // ############################################################
     // #####                    Destruction                   #####
 …
         // Destroy calibrator helper handler and state
-        delete keyDetector_;
         this->destroyState("calibrator");
         // Destroy KeyDetector and state
+        delete calibratorCallbackHandler_;
+        this->destroyState("detector");
+        calibratorCallbackHandler_->destroy();
         // destroy the empty InputState
         this->destroyStateInternal(this->emptyState_);
 …
         // Check whether we have to change the mouse mode
+        MouseMode::Value requestedMode = MouseMode::Dontcare;
         std::vector<InputState*>& mouseStates = devices_[InputDeviceEnumerator::Mouse]->getStateListRef();
+        if (mouseStates.empty() && bExclusiveMouse_ ||
+            !mouseStates.empty() && mouseStates.front()->getIsExclusiveMouse() != bExclusiveMouse_)
+        {
+            bExclusiveMouse_ = !bExclusiveMouse_;
+        if (mouseStates.empty())
+            requestedMode = MouseMode::Nonexclusive;
+        else
+            requestedMode = mouseStates.front()->getMouseMode();
+        if (requestedMode != MouseMode::Dontcare && mouseMode_ != requestedMode)
+        {
+            mouseMode_ = requestedMode;
             if (!GraphicsManager::getInstance().isFullScreen())
                 this->reloadInternal();
 …
+        }
         statesByName_.erase(state->getName());
         delete state;
+        state->destroy();
+    }
+}

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

-                      r5781
+                      r5929
         // Various getters and setters
         //-------------------------------
-        //! Sets the the name of the command used by the KeyDetector as callback.
-        void setKeyDetectorCallback(const std::string& command);
         //! Returns the number of joy stick that have been created since the c'tor or last call to reload().
         unsigned int getJoyStickQuantity() const
 …
         OIS::InputManager*                  oisInputManager_;      //!< OIS input manager
         std::vector<InputDevice*>           devices_;              //!< List of all input devices (keyboard, mouse, joy sticks)
         bool                                bExclusiveMouse_;      //!< Currently applied mouse mode
+        MouseMode::Value                    mouseMode_;            //!< Currently applied mouse mode
         // some internally handled states and handlers
         InputState*                         emptyState_;           //!< Lowest priority states (makes handling easier)
-        KeyDetector*                        keyDetector_;          //!< KeyDetector instance
         //! InputBuffer that reacts to the Enter key when calibrating the joy sticks
         InputBuffer*                        calibratorCallbackHandler_;

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

r5781	r5929
37	37	, bAlwaysGetsInput_(bAlwaysGetsInput)
38	38	, bTransparent_(bTransparent)
39		, ~~bExclusiveMouse_(tru~~e)
	39	, mouseMode_(MouseMode::Dontcare)
40	40	, bExpired_(true)
41	41	, handlers_(2)

code/trunk/src/libraries/core/input/InputState.h

-                      r5781
+                      r5929
         static const int Detector     = HighPriority + 2;
     };
+    namespace MouseMode
+    {
+        enum Value
+        {
+            Exclusive,
+            Nonexclusive,
+            Dontcare
+        };
+    }
     /**
 …
         void setHandler        (InputHandler* handler);
         void setIsExclusiveMouse(bool value) { bExclusiveMouse_ = value; this->bExpired_ = true; }
         bool getIsExclusiveMouse() const { return bExclusiveMouse_; }
+        void setMouseMode(MouseMode::Value value) { mouseMode_ = value; this->bExpired_ = true; }
+        MouseMode::Value getMouseMode() const { return mouseMode_; }
         //! Returns the name of the state (which is unique!)
 …
         const bool                  bAlwaysGetsInput_;      //!< See class declaration for explanation
         const bool                  bTransparent_;          //!< See class declaration for explanation
         bool                        bExclusiveMouse_;       //!< See class declaration for explanation
+        MouseMode::Value            mouseMode_;             //!< See class declaration for explanation
         int                         priority_;              //!< Current priority (might change)
         bool                        bExpired_;              //!< See hasExpired()

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

-                      r5781
+                      r5929
  */
-/**
- @file
- @brief Implementation of the different input handlers.
- */
 #include "KeyBinder.h"
 #include "util/Convert.h"
 #include "util/Debug.h"
+#include "util/Exception.h"
 #include "core/ConfigValueIncludes.h"
 #include "core/CoreIncludes.h"
 …
         Constructor that does as little as necessary.
     */
     KeyBinder::KeyBinder()
+    KeyBinder::KeyBinder(const std::string& filename)
         : deriveTime_(0.0f)
+        , filename_(filename)
+    {
         mouseRelative_[0] = 0;
 …
         // set them here to use allHalfAxes_
         setConfigValues();
+        // Load the bindings if filename was given
+        if (!this->filename_.empty())
+            this->loadBindings();
+    }
 …
     @brief
         Loads the key and button bindings.
+    @return
+        True if loading succeeded.
+    */
+    void KeyBinder::loadBindings(const std::string& filename)
+    */
+    void KeyBinder::loadBindings()
+    {
         COUT(3) << "KeyBinder: Loading key bindings..." << std::endl;
+        if (filename.empty())
+            return;
+        if (this->configFile_ == ConfigFileType::NoType)
+        {
+            // Get a new ConfigFileType from the ConfigFileManager
+            this->configFile_ = ConfigFileManager::getInstance().getNewConfigFileType();
+        }
+        ConfigFileManager::getInstance().setFilename(this->configFile_, filename);
+        // Get a new ConfigFileType from the ConfigFileManager
+        this->configFile_ = ConfigFileManager::getInstance().getNewConfigFileType();
+        ConfigFileManager::getInstance().setFilename(this->configFile_, this->filename_);
         // Parse bindings and create the ConfigValueContainers if necessary
-        clearBindings();
         for (std::map<std::string, Button*>::const_iterator it = allButtons_.begin(); it != allButtons_.end(); ++it)
             it->second->readConfigValue(this->configFile_);

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

-                      r5781
+                      r5929
+ *
  */
-/**
-@file
-@brief
-    Different definitions of input processing.
-*/
 #ifndef _KeyBinder_H__
 …
     /**
     @brief
+        Handles mouse, keyboard and joy stick input while in the actual game mode.
+        Manages the key bindings.
+        Maps mouse, keyboard and joy stick input to command strings and executes them.
+        The bindings are stored in ini-files (like the one for configValues) in the config Path.
+    @remarks
+        You cannot change the filename because the KeyBinderManager maps these filenames to the
+        KeyBinders. If you need to load other bindings, just create a new one.
     */
     class _CoreExport KeyBinder : public InputHandler, public JoyStickQuantityListener
+    {
     public:
         KeyBinder ();
+        KeyBinder (const std::string& filename);
         virtual ~KeyBinder();
-        void loadBindings(const std::string& filename);
         void clearBindings();
         bool setBinding(const std::string& binding, const std::string& name, bool bTemporary = false);
+        const std::string& getBindingsFilename()
+            { return this->filename_; }
         void setConfigValues();
         void resetJoyStickAxes();
     protected: // functions
+        void loadBindings();
+        void buttonThresholdChanged();
+        void initialiseJoyStickBindings();
+        void compilePointerLists();
+        // from JoyStickQuantityListener interface
+        virtual void JoyStickQuantityChanged(const std::vector<JoyStick*>& joyStickList);
         void allDevicesUpdated(float dt);
         void mouseUpdated(float dt);
 …
         // internal
         void tickHalfAxis(HalfAxis& halfAxis);
-        void buttonThresholdChanged();
-        // from JoyStickQuantityListener interface
-        virtual void JoyStickQuantityChanged(const std::vector<JoyStick*>& joyStickList);
-        void initialiseJoyStickBindings();
-        void compilePointerLists();
         void buttonPressed (const KeyEvent& evt);
 …
         float deriveTime_;
+        //! Name of the file used in this KeyBinder (constant!)
+        const std::string filename_;
         //! Config file used. ConfigFileType::NoType in case of KeyDetector. Also indicates whether we've already loaded.
         ConfigFileType configFile_;
 …
     };
     inline void KeyBinder::buttonPressed (const KeyEvent& evt)
     { assert(!keys_[evt.getKeyCode()].name_.empty()); keys_[evt.getKeyCode()].execute(KeybindMode::OnPress); }

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

-                      r5781
+                      r5929
 #include "KeyDetector.h"
 #include "util/Debug.h"
+#include "core/ConsoleCommand.h"
 #include "core/CoreIncludes.h"
+#include "core/ScopedSingletonManager.h"
 #include "Button.h"
+#include "InputManager.h"
+#include "InputState.h"
 namespace orxonox
+{
     /**
     @brief
         Constructor
+    */
+    std::string KeyDetector::callbackCommand_s = "KeyDetectorKeyPressed";
+    KeyDetector* KeyDetector::singletonPtr_s = 0;
+    ManageScopedSingleton(KeyDetector, ScopeID::Graphics, false);
     KeyDetector::KeyDetector()
+        : KeyBinder("")
+    {
         RegisterObject(KeyDetector);
+        CommandExecutor::addConsoleCommandShortcut(createConsoleCommand(createFunctor(&KeyDetector::callback,  this), callbackCommand_s));
+        this->assignCommands();
+        inputState_ = InputManager::getInstance().createInputState("detector", false, false, InputStatePriority::Detector);
+        // Create a callback to avoid buttonHeld events after the key has been detected
+        inputState_->setLeaveFunctor(createFunctor(&InputManager::clearBuffers, &InputManager::getInstance()));
+        inputState_->setHandler(this);
+    }
-    /**
-    @brief
-        Destructor
-    */
     KeyDetector::~KeyDetector()
+    {
+        inputState_->setHandler(NULL);
+        InputManager::getInstance().destroyState("detector");
+    }
+    /**
+    @brief
+        Assigns all the buttons 'command' plus the button's name.
+    */
+    void KeyDetector::setCallbackCommand(const std::string& command)
+    void KeyDetector::assignCommands()
+    {
         callbackCommand_ = command;
+        // Assign every button/axis the same command, but with its name as argument
         clearBindings();
         for (std::map<std::string, Button*>::const_iterator it = allButtons_.begin(); it != allButtons_.end(); ++it)
+        {
             it->second->bindingString_ = callbackCommand_ + it->second->groupName_ + "." + it->second->name_;
+            it->second->bindingString_ = callbackCommand_s + " " + it->second->groupName_ + "." + it->second->name_;
             it->second->parse();
+        }
+    }
+    void KeyDetector::callback(const std::string& name)
+    {
+        // Call the registered function
+        if (this->callbackFunction_)
+            (*this->callbackFunction_)(name);
+    }
 …
+    {
         KeyBinder::JoyStickQuantityChanged(joyStickList);
+        if (!callbackCommand_.empty())
+            setCallbackCommand(callbackCommand_);
+        this->assignCommands();
+    }
+}

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

-                      r5781
+                      r5929
 #include "InputPrereqs.h"
 #include <string>
+#include "util/Singleton.h"
 #include "KeyBinder.h"
 namespace orxonox
+{
     class _CoreExport KeyDetector : public KeyBinder
+    class _CoreExport KeyDetector : public KeyBinder, public Singleton<KeyDetector>
+    {
+        friend class Singleton<KeyDetector>;
     public:
         KeyDetector();
         ~KeyDetector();
+        void setCallbackCommand(const std::string& command);
         void JoyStickQuantityChanged(const std::vector<JoyStick*>& joyStickList);
+        void setCallback(Functor* function) { this->callbackFunction_ = function; }
     private:
+        std::string callbackCommand_;
+        KeyDetector(const KeyDetector&);
+        void callback(const std::string& name);
+        void JoyStickQuantityChanged(const std::vector<JoyStick*>& joyStickList);
+        void assignCommands();
+        Functor* callbackFunction_;
+        InputState* inputState_;
+        static std::string callbackCommand_s;
+        static KeyDetector* singletonPtr_s;
     };
+}

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

-                      r5781
+                      r5929
 #ifdef ORXONOX_PLATFORM_LINUX
+        {
+            // Mouse grab console command
+            FunctorMember<Mouse>* functor = createFunctor(&Mouse::grab);
+            functor->setObject(this);
+            this->getIdentifier()->addConsoleCommand(createConsoleCommand(functor, "grab"), false);
+        }
+        {
+            // Mouse ungrab console command
+            FunctorMember<Mouse>* functor = createFunctor(&Mouse::ungrab);
+            functor->setObject(this);
+            this->getIdentifier()->addConsoleCommand(createConsoleCommand(functor, "ungrab"), false);
+        }
+        // Mouse grab console command
+        this->getIdentifier()->addConsoleCommand(createConsoleCommand(createFunctor(&Mouse::grab, this), "grab"), false);
+        // Mouse ungrab console command
+        this->getIdentifier()->addConsoleCommand(createConsoleCommand(createFunctor(&Mouse::ungrab, this), "ungrab"), false);
 #endif
+    }

code/trunk/src/libraries/network/Client.cc

-                      r5781
+                      r5929
 #include <cassert>
+#include "util/Clock.h"
 #include "util/Debug.h"
-#include "core/Clock.h"
 #include "synchronisable/Synchronisable.h"
 #include "packet/Chat.h"
 #include "packet/Gamestate.h"
 #include "FunctionCallManager.h"
+#include "core/CoreIncludes.h"
+#include "core/Game.h"
 namespace orxonox
 …
     return;
+  }
+  void Client::connectionClosed()
+  {
+    ObjectList<Synchronisable>::iterator it;
+    for(it = ObjectList<Synchronisable>::begin(); it; )
+    {
+      if( it->getSyncMode() != 0x0 )
+        (it++)->destroy();
+      else
+      {
+        ++it;
+      }
+    }
+    Game::getInstance().popState();
+    Game::getInstance().popState();
+  }
+}

code/trunk/src/libraries/network/Client.h

-                      r5781
+                      r5929
 #include <string>
+#include "util/UtilPrereqs.h"
 #include "ClientConnection.h"
 #include "GamestateClient.h"
 …
     void update(const Clock& time);
+  protected:
+    virtual void connectionClosed();
   private:
     Client(const Client& copy); // not used

code/trunk/src/libraries/network/ClientConnection.cc

r5781	r5929
118	118	case ENET_EVENT_TYPE_DISCONNECT:
119	119	COUT(4) << "received disconnect confirmation from server" << endl;
	120	this->connectionClosed();
120	121	return true;
121	122	}
…	…
123	124	}
124	125	enet_peer_reset( this->server_ );
	126	this->connectionClosed();
125	127	return false;
126	128	}
…	…
133	135	}
134	136
135		void ClientConnection::add~~Client~~(ENetEvent* event)
	137	void ClientConnection::addPeer(ENetEvent* event)
136	138	{
137	139	assert(0);
138	140	}
139		void ClientConnection::~~disconnect~~Peer(ENetEvent* event)
	141	void ClientConnection::removePeer(ENetEvent* event)
140	142	{
141	143	this->established_=false;
142	144	COUT(1) << "Received disconnect Packet from Server!" << endl;
143	145	// server closed the connection
	146	this->connectionClosed();
144	147	}
145	148

code/trunk/src/libraries/network/ClientConnection.h

-                      r5781
+                      r5929
     bool addPacket(ENetPacket *packet);
     inline bool isConnected(){ return this->established_; }
+  protected:
+    virtual void connectionClosed()=0;
   private:
     virtual void addClient(ENetEvent* event);
     virtual void disconnectPeer(ENetEvent* event);
+    virtual void addPeer(ENetEvent* event);
+    virtual void removePeer(ENetEvent* event);
     bool disconnectConnection();

code/trunk/src/libraries/network/ClientConnectionListener.cc

-                      r5781
+                      r5929
 #include "ClientInformation.h"
+namespace orxonox{
+namespace orxonox
+{
+    ClientConnectionListener::ClientConnectionListener()
+    {
+        RegisterRootObject(ClientConnectionListener);
+    }
+  ClientConnectionListener::ClientConnectionListener()
+  {
+    RegisterRootObject(ClientConnectionListener);
+  }
+    void ClientConnectionListener::broadcastClientConnected(unsigned int clientID)
+    {
+        for (ObjectList<ClientConnectionListener>::iterator it = ObjectList<ClientConnectionListener>::begin(); it != ObjectList<ClientConnectionListener>::end(); ++it)
+            it->clientConnected(clientID);
+    }
+    void ClientConnectionListener::broadcastClientDisconnected(unsigned int clientID)
+    {
+        for (ObjectList<ClientConnectionListener>::iterator it = ObjectList<ClientConnectionListener>::begin(); it != ObjectList<ClientConnectionListener>::end(); ++it)
+            it->clientDisconnected(clientID);
+    }
+  void ClientConnectionListener::getConnectedClients(){
+    if(GameMode::showsGraphics())
+      this->clientConnected(0); //server client id
+    ClientInformation *client = ClientInformation::getBegin();
+    while(client){
+      this->clientConnected(client->getID());
+      client=client->next();
+    void ClientConnectionListener::getConnectedClients()
+    {
+        ClientInformation* client = ClientInformation::getBegin();
+        while (client)
+        {
+            this->clientConnected(client->getID());
+            client = client->next();
+        }
+    }
+  }
+}

code/trunk/src/libraries/network/ClientConnectionListener.h

-                      r5781
+                      r5929
 #include "core/OrxonoxClass.h"
+namespace orxonox{
+namespace orxonox
+{
+    class _NetworkExport ClientConnectionListener : virtual public OrxonoxClass
+    {
+        public:
+            ClientConnectionListener();
+            virtual ~ClientConnectionListener() {}
+            static void broadcastClientConnected(unsigned int clientID);
+            static void broadcastClientDisconnected(unsigned int clientID);
+  class _NetworkExport ClientConnectionListener : virtual public OrxonoxClass
+  {
+    friend class Server;
+            virtual void clientConnected(unsigned int clientID) = 0;
+            virtual void clientDisconnected(unsigned int clientID) = 0;
+  public:
+    ClientConnectionListener();
+    virtual ~ClientConnectionListener() {}
+    void getConnectedClients();
+  protected:
+    virtual void clientConnected(unsigned int clientID) = 0;
+    virtual void clientDisconnected(unsigned int clientID) = 0;
+  };
+        protected:
+            void getConnectedClients();
+    };
+}

code/trunk/src/libraries/network/Connection.cc

Property svn:eol-style set to native

-                      r5781
+                      r5929
         // log handling ================
         case ENET_EVENT_TYPE_CONNECT:
           addClient( &event );
+          addPeer( &event );
           break;
         case ENET_EVENT_TYPE_DISCONNECT:
           disconnectPeer( &event );
+          removePeer( &event );
           break;
         case ENET_EVENT_TYPE_RECEIVE:

code/trunk/src/libraries/network/Connection.h

Property svn:eol-style set to native

-                      r5781
+                      r5929
     int service(ENetEvent* event);
     void disconnectPeer(ENetPeer *peer);
+    virtual void disconnectPeer(ENetPeer *peer);
     void processQueue();
     virtual void addClient(ENetEvent* event)=0;
     virtual void disconnectPeer(ENetEvent* event)=0;
+    virtual void addPeer(ENetEvent* event)=0;
+    virtual void removePeer(ENetEvent* event)=0;
     virtual bool processPacket(ENetEvent* event);

code/trunk/src/libraries/network/GamestateClient.cc

r5781	r5929
108	108	ObjectList<Synchronisable>::iterator temp=it;
109	109	++it;
110		~~delete *temp;~~
	110	temp->destroy(); // or delete?
111	111	}
112	112

code/trunk/src/libraries/network/GamestateManager.cc

-                      r5781
+                      r5929
         delete (*it2).second;
+    }
     delete this->trafficControl_;
+    this->trafficControl_->destroy();
 //     delete this->threadMutex_;
 //     delete this->threadPool_;
 …
       finishGamestate( cid, &clientGamestates.back(), client, reference );
       //FunctorMember<GamestateManager>* functor =
+//       ExecutorMember<GamestateManager>* executor = createExecutor( createFunctor(&GamestateManager::finishGamestate) );
+//       executor->setObject(this);
+//       ExecutorMember<GamestateManager>* executor = createExecutor( createFunctor(&GamestateManager::finishGamestate, this) );
 //       executor->setDefaultValues( cid, &clientGamestates.back(), client, reference );
 //       (*static_cast<Executor*>(executor))();

code/trunk/src/libraries/network/NetworkFunction.cc

r5781	r5929
60	60	std::map<std::string, NetworkFunctionBase*>::iterator it;
61	61	for( it=NetworkFunctionBase::nameMap_.begin(); it!=NetworkFunctionBase::nameMap_.end(); ++it )
62		~~delete it->second~~;
	62	it->second->destroy();
63	63	}
64	64

code/trunk/src/libraries/network/NetworkPrereqs.h

-                      r5781
+                      r5929
 /**
+  @file
+  @brief Contains all the necessary forward declarations for all classes and structs.
+@file
+@brief
+    Shared library macros, enums, constants and forward declarations for the network library
 */
 …
 // Shared library settings
 //-----------------------------------------------------------------------
 #if defined(ORXONOX_PLATFORM_WINDOWS) && !defined( NETWORK_STATIC_BUILD )
 #  ifdef NETWORK_SHARED_BUILD
 …
 //-----------------------------------------------------------------------
 // Library global contants
+// Constants
 //-----------------------------------------------------------------------
 namespace orxonox
+{
   static const unsigned int GAMESTATEID_INITIAL = static_cast<unsigned int>(-1);
   static const unsigned int CLIENTID_UNKNOWN    = static_cast<unsigned int>(-2);
+  static const uint32_t     OBJECTID_UNKNOWN    = static_cast<uint32_t>(-1);
+}
+//-----------------------------------------------------------------------
+// Enums
+//-----------------------------------------------------------------------
+namespace orxonox
+{
+  namespace packet
+  {
+    namespace PacketFlag
+    {
+      enum Value
+      {
+        Reliable   = 1,
+        Unsequence = 2,
+        NoAllocate = 4
+      };
+    }
+  }
+}
 …
 namespace orxonox
+{
+  class ChatListener;
   class Client;
   class ClientConnection;
   class ClientConnectionListener;
-  class ClientFrameListener;
   class ClientInformation;
   class Connection;
   class FunctionCallManager;
   class GamestateClient;
+  class GamestateHandler;
   class GamestateManager;
+  class GamestateHandler;
+  class NetworkCallbackBase;
+  template <class T> class NetworkCallback;
+  class NetworkCallbackManager;
+  class Host;
   class NetworkFunctionBase;
+  struct NetworkFunctionPointer;
   class NetworkFunctionStatic;
+  template <class T>
+  class NetworkMemberFunction;
   class NetworkMemberFunctionBase;
-  template <class T> class NetworkMemeberFunction;
-  struct NetworkFunctionPointer;
   class Server;
   class ServerConnection;
-  class ServerFrameListener;
-  class Synchronisable;
-  class SynchronisableVariableBase;
-  template <class T> class SynchronisableVariable;
-  template <class T> class SynchronisableVariableBidirectional;
-  struct ClientList;
-  struct PacketEnvelope;
-  struct QueueItem;
-  struct syncData;
   class TrafficControl;
-  class obj;
-  class objInfo;
+  // packet
   namespace packet
+  {
 …
     class Chat;
     class ClassID;
+    class DeleteObjects;
     class FunctionCalls;
     class FunctionIDs;
     class Gamestate;
-    class NetworkIDs;
     class Packet;
     class Welcome;
+  }
+    namespace PacketFlag
+    {
+      enum Value
+      {
+        Reliable   = 1,
+        Unsequence = 2,
+        NoAllocate = 4
+      };
+    }
+  }
+  // synchronisable
+  template <class T>
+  class NetworkCallback;
+  class NetworkCallbackBase;
+  class NetworkCallbackManager;
+  class Synchronisable;
+  class SynchronisableHeader;
+  template <class T>
+  class SynchronisableVariable;
+  class SynchronisableVariableBase;
+  template <class T>
+  class SynchronisableVariableBidirectional;
+}

code/trunk/src/libraries/network/Server.cc

-                      r5781
+                      r5929
 #include <string>
+#include "util/Clock.h"
 #include "util/Debug.h"
-#include "core/Clock.h"
 #include "core/ObjectList.h"
 #include "core/Executor.h"
 …
     packet::DeleteObjects *del = new packet::DeleteObjects();
     if(!del->fetchIDs())
+    {
+      delete del;
       return true;  //everything ok (no deletes this tick)
+    }
 //     COUT(3) << "sending DeleteObjects" << std::endl;
     while(temp != NULL){
 …
   void Server::addClient(ENetEvent *event){
+  void Server::addPeer(ENetEvent *event){
     static unsigned int newid=1;
 …
     // inform all the listeners
+    ObjectList<ClientConnectionListener>::iterator listener = ObjectList<ClientConnectionListener>::begin();
+    while(listener){
+      listener->clientConnected(newid);
+      listener++;
+    }
+    ClientConnectionListener::broadcastClientConnected(newid);
     ++newid;
 …
     createClient(temp->getID());
+}
+  void Server::removePeer(ENetEvent *event)
+  {
+    COUT(4) << "removing client from list" << std::endl;
+    ClientInformation *client = ClientInformation::findClient(&event->peer->address);
+    if(!client)
+      return;
+    else
+    {
+      //ServerConnection::disconnectClient( client );
+      ClientConnectionListener::broadcastClientDisconnected( client->getID() );
+      delete client;
+    }
+  }
   bool Server::createClient(int clientID){
 …
     ServerConnection::disconnectClient( client );
     GamestateManager::removeClient(client);
+// inform all the listeners
+    ObjectList<ClientConnectionListener>::iterator listener = ObjectList<ClientConnectionListener>::begin();
+    while(listener){
+      listener->clientDisconnected(client->getID());
+      ++listener;
+    }
+    delete client; //remove client from list
+    // inform all the listeners
+    ClientConnectionListener::broadcastClientDisconnected(client->getID());
+  }

code/trunk/src/libraries/network/Server.h

-                      r5781
+                      r5929
 #include "NetworkPrereqs.h"
+#include "util/UtilPrereqs.h"
 #include "core/CorePrereqs.h"
 #include "Host.h"
 …
     unsigned int playerID(){return 0;}
+    void addClient(ENetEvent *event);
+    void addPeer(ENetEvent *event);
+    void removePeer(ENetEvent *event);
     bool createClient(int clientID);
     void disconnectClient( ClientInformation *client);

code/trunk/src/libraries/network/ServerConnection.cc

Property svn:eol-style set to native

-                      r5781
+                      r5929
+  {
     Connection::disconnectPeer( client->getPeer() );
-    delete client;
+  }
-  void ServerConnection::disconnectPeer( ENetEvent* event )
+  {
-    COUT(4) << "removing client from list" << std::endl;
-    ClientInformation *client = ClientInformation::findClient(&event->peer->address);
-    if(!client)
-      return;
-    else
-      ServerConnection::disconnectClient( client );
+  }
 …
     ClientInformation *client = ClientInformation::findClient(clientID);
     if(client)
       disconnectClient(client);
+      ServerConnection::disconnectClient(client);
+  }
 …
     ClientInformation *temp = ClientInformation::getBegin();
     while(temp!=0){
       disconnectClient( temp );
+      ServerConnection::disconnectClient( temp );
       temp = temp->next();
+    }
 …
           break;
         case ENET_EVENT_TYPE_DISCONNECT:
+          if(ClientInformation::findClient(&(event.peer->address)))
+            delete ClientInformation::findClient(&(event.peer->address));
+          removePeer( &event );
           temp = ClientInformation::getBegin();
           break;

code/trunk/src/libraries/network/ServerConnection.h

Property svn:eol-style set to native

r5781	r5929
59	59	static bool addPacketAll(ENetPacket *packet);
60	60	virtual void disconnectClient(ClientInformation *client);
61		~~void disconnectPeer( ENetEvent* event );~~
62	61	void disconnectClient(int clientID);
63	62	protected:

code/trunk/src/libraries/network/packet/CMakeLists.txt

-                      r5781
+                      r5929
 ADD_SOURCE_FILES(NETWORK_SRC_FILES
+COMPILATION_BEGIN PacketCompilation.cc
   Acknowledgement.cc
   Chat.cc
 …
   Packet.cc
   Welcome.cc
+COMPILATION_END
+)

code/trunk/src/libraries/network/packet/ClassID.cc

-                      r5781
+                      r5929
   Identifier *id;
   std::string classname;
   unsigned int nrOfClasses=0;
+  unsigned int nrOfClasses=0;
   unsigned int packetSize=2*sizeof(uint32_t); //space for the packetID and for the nrofclasses
   uint32_t network_id;
   flags_ = flags_ | PACKET_FLAGS_CLASSID;
   std::queue<std::pair<uint32_t, std::string> > tempQueue;
   //calculate total needed size (for all strings and integers)
   std::map<std::string, Identifier*>::const_iterator it = Factory::getFactoryMapBegin();
   for(;it != Factory::getFactoryMapEnd();++it){
+  std::map<std::string, Identifier*>::const_iterator it = Identifier::getStringIdentifierMapBegin();
+  for(;it != Identifier::getStringIdentifierMapEnd();++it){
     id = (*it).second;
     if(id == NULL)
+    if(id == NULL || !id->hasFactory())
       continue;
     classname = id->getName();
     network_id = id->getNetworkID();
-    if(network_id==0)
-      COUT(3) << "we got a null class id: " << id->getName() << std::endl;
     // now push the network id and the classname to the stack
     tempQueue.push( std::pair<unsigned int, std::string>(network_id, classname) );
 …
     packetSize += (classname.size()+1)+sizeof(uint32_t)+sizeof(uint32_t);
+  }
   this->data_=new uint8_t[ packetSize ];
   //set the appropriate packet id
   assert(this->data_);
   *(Type::Value *)(this->data_ + _PACKETID ) = Type::ClassID;
   uint8_t *temp=data_+sizeof(uint32_t);
   // save the number of all classes
   *(uint32_t*)temp = nrOfClasses;
   temp += sizeof(uint32_t);
   // now save all classids and classnames
   std::pair<uint32_t, std::string> tempPair;
 …
     temp+=2*sizeof(uint32_t)+tempPair.second.size()+1;
+  }
   COUT(5) << "classid packetSize is " << packetSize << endl;
+}
 …
   temp += sizeof(uint32_t);
   totalsize += sizeof(uint32_t); // storage size for nr of all classes
   for(unsigned int i=0; i<nrOfClasses; i++){
     totalsize += 2*sizeof(uint32_t) + *(uint32_t*)(temp + sizeof(uint32_t));
 …
   uint32_t stringsize;
   unsigned char *classname;
   //clean the map of network ids
   Factory::cleanNetworkIDs();
+  //clear the map of network ids
+  Identifier::clearNetworkIDs();
   COUT(4) << "=== processing classids: " << endl;
   std::pair<uint32_t, std::string> tempPair;
 …
   nrOfClasses = *(uint32_t*)temp;
   temp += sizeof(uint32_t);
   for( int i=0; i<nrOfClasses; i++){
     networkID = *(uint32_t*)temp;

code/trunk/src/libraries/network/packet/Gamestate.cc

r5781	r5929
378	378	rawDiff( dest2, dest, basep, header_->getDataSize(), base->header_->getDataSize() );
379	379	assert( memcmp( dest2, gs, dest_length) == 0 );
	380	delete dest2;
380	381	#endif
381	382

code/trunk/src/libraries/network/synchronisable/Synchronisable.cc

-                      r5781
+                      r5929
   /**
   * Constructor:
   * Initializes all Variables and sets the right objectID
+  * Initializes all Variables and sets the right objectID_
   */
   Synchronisable::Synchronisable(BaseObject* creator){
+  Synchronisable::Synchronisable(BaseObject* creator ){
     RegisterRootObject(Synchronisable);
     static uint32_t idCounter=0;
 …
     if ( GameMode::isMaster() || ( Host::running() && Host::isServer() ) )
+    {
+      this->objectID = idCounter++; //this is only needed when running a server
+    //add synchronisable to the objectMap
+      objectMap_[this->objectID] = this;
+      this->setObjectID( idCounter++ );
+    }
     else
+    {
+      objectID=OBJECTID_UNKNOWN;
+      this->setObjectMode(0x0);   //make sure this object doesn't get synchronized
+    }
+    classID = static_cast<uint32_t>(-1);
+      objectID_=OBJECTID_UNKNOWN;
+    }
+    classID_ = static_cast<uint32_t>(-1);
     // set dataSize to 0
 …
     // get creator id
+    this->creatorID = OBJECTID_UNKNOWN;
+    searchcreatorID:
+    if( creator )
+      this->creatorID_ = creator->getSceneID();
+    else
+      this->creatorID_ = OBJECTID_UNKNOWN;
+    /*searchcreatorID:
     if (creator)
+    {
 …
         if (synchronisable_creator && synchronisable_creator->objectMode_)
+        {
             this->creatorID = synchronisable_creator->getObjectID();
+            this->creatorID = synchronisable_creator->getScene()->getObjectID();
+        }
         else if (creator != creator->getCreator())
 …
             goto searchcreatorID;
+        }
+    }
+    }*/
+  }
   /**
    * Destructor:
    * Delete all callback objects and remove objectID from the objectMap_
+   * Delete all callback objects and remove objectID_ from the objectMap_
    */
   Synchronisable::~Synchronisable(){
 …
       // remove object from the static objectMap
       if (this->objectMode_ != 0x0 && (Host::running() && Host::isServer()))
         deletedObjects_.push(objectID);
+        deletedObjects_.push(objectID_);
+    }
     // delete all Synchronisable Variables from syncList ( which are also in stringList )
 …
     stringList.clear();
     std::map<uint32_t, Synchronisable*>::iterator it;
     it = objectMap_.find(objectID);
+    it = objectMap_.find(objectID_);
     if (it != objectMap_.end())
       objectMap_.erase(it);
 …
     Synchronisable *no = orxonox_cast<Synchronisable*>(bo);
     assert(no);
+    no->objectID=header.getObjectID();
+    no->creatorID=header.getCreatorID(); //TODO: remove this
+    no->classID=header.getClassID();
+    COUT(4) << "fabricate objectID: " << no->objectID << " classID: " << no->classID << std::endl;
+    assert( Synchronisable::objectMap_.find(header.getObjectID()) == Synchronisable::objectMap_.end() );
+    no->setObjectID(header.getObjectID());
+    //no->creatorID=header.getCreatorID(); //TODO: remove this
+    no->setClassID(header.getClassID());
+    assert(no->creatorID_ == header.getCreatorID());
+    //assert(no->classID_ == header.getClassID());
+    COUT(4) << "fabricate objectID_: " << no->objectID_ << " classID_: " << no->classID_ << std::endl;
           // update data and create object/entity...
-    assert( Synchronisable::objectMap_.find(header.getObjectID()) == Synchronisable::objectMap_.end() );
-    Synchronisable::objectMap_[header.getObjectID()] = no;
     bool b = no->updateData(mem, mode, true);
     assert(b);
 …
   /**
    * Finds and deletes the Synchronisable with the appropriate objectID
    * @param objectID objectID of the Synchronisable
+   * Finds and deletes the Synchronisable with the appropriate objectID_
+   * @param objectID_ objectID_ of the Synchronisable
    * @return true/false
    */
   bool Synchronisable::deleteObject(uint32_t objectID){
     if(!getSynchronisable(objectID))
+  bool Synchronisable::deleteObject(uint32_t objectID_){
+    if(!getSynchronisable(objectID_))
       return false;
     assert(getSynchronisable(objectID)->objectID==objectID);
     Synchronisable *s = getSynchronisable(objectID);
+    assert(getSynchronisable(objectID_)->objectID_==objectID_);
+    Synchronisable *s = getSynchronisable(objectID_);
     if(s)
       delete s;
+      s->destroy(); // or delete?
     else
       return false;
 …
   /**
    * This function looks up the objectID in the objectMap_ and returns a pointer to the right Synchronisable
    * @param objectID objectID of the Synchronisable
    * @return pointer to the Synchronisable with the objectID
    */
   Synchronisable* Synchronisable::getSynchronisable(uint32_t objectID){
+   * This function looks up the objectID_ in the objectMap_ and returns a pointer to the right Synchronisable
+   * @param objectID_ objectID_ of the Synchronisable
+   * @return pointer to the Synchronisable with the objectID_
+   */
+  Synchronisable* Synchronisable::getSynchronisable(uint32_t objectID_){
     std::map<uint32_t, Synchronisable*>::iterator it1;
     it1 = objectMap_.find(objectID);
+    it1 = objectMap_.find(objectID_);
     if (it1 != objectMap_.end())
       return it1->second;
 …
 //     ObjectList<Synchronisable>::iterator it;
 //     for(it = ObjectList<Synchronisable>::begin(); it; ++it){
 //       if( it->getObjectID()==objectID ){
 //         objectMap_[objectID] = *it;
+//       if( it->getObjectID()==objectID_ ){
+//         objectMap_[objectID_] = *it;
 //         return *it;
 //       }
 …
   /**
    * This function takes all SynchronisableVariables out of the Synchronisable and saves them together with the size, objectID and classID to the given memory
+   * This function takes all SynchronisableVariables out of the Synchronisable and saves them together with the size, objectID_ and classID_ to the given memory
    * takes a pointer to already allocated memory (must have at least getSize bytes length)
    * structure of the bitstream:
    * |totalsize,objectID,classID,var1,var2,string1_length,string1,var3,...|
+   * |totalsize,objectID_,classID_,var1,var2,string1_length,string1,var3,...|
    * length of varx: size saved int syncvarlist
    * @param mem pointer to allocated memory with enough size
 …
     uint32_t tempsize = 0;
 #ifndef NDEBUG
     if (this->classID==0)
+    if (this->classID_==0)
       COUT(3) << "classid 0 " << this->getIdentifier()->getName() << std::endl;
 #endif
+    if (this->classID == static_cast<uint32_t>(-1))
+        this->classID = this->getIdentifier()->getNetworkID();
+    assert(ClassByID(this->classID));
+    assert(this->classID==this->getIdentifier()->getNetworkID());
+    if (this->classID_ == static_cast<uint32_t>(-1))
+        this->classID_ = this->getIdentifier()->getNetworkID();
+    assert(ClassByID(this->classID_));
+    assert(this->classID_==this->getIdentifier()->getNetworkID());
+    assert(this->objectID_!=OBJECTID_UNKNOWN);
     std::vector<SynchronisableVariableBase*>::iterator i;
 …
     COUT(5) << "Synchronisable getting data from objectID: " << objectID << " classID: " << classID << std::endl;
+    COUT(5) << "Synchronisable getting data from objectID_: " << objectID_ << " classID_: " << classID_ << std::endl;
     // copy to location
     for(i=syncList.begin(); i!=syncList.end(); ++i){
 …
     tempsize += SynchronisableHeader::getSize();
     header.setObjectID( this->objectID );
     header.setCreatorID( this->creatorID );
     header.setClassID( this->classID );
+    header.setObjectID( this->objectID_ );
+    header.setCreatorID( this->creatorID_ );
+    header.setClassID( this->classID_ );
     header.setDataAvailable( true );
     header.setDataSize( tempsize );
 …
     // start extract header
     SynchronisableHeader syncHeader(mem);
     assert(syncHeader.getObjectID()==this->objectID);
     assert(syncHeader.getCreatorID()==this->creatorID);
     assert(syncHeader.getClassID()==this->classID);
+    assert(syncHeader.getObjectID()==this->objectID_);
+    assert(syncHeader.getCreatorID()==this->creatorID_);
+    assert(syncHeader.getClassID()==this->classID_);
     if(syncHeader.isDataAvailable()==false){
       mem += syncHeader.getDataSize();
 …
     // stop extract header
     //COUT(5) << "Synchronisable: objectID " << syncHeader.getObjectID() << ", classID " << syncHeader.getClassID() << " size: " << syncHeader.getDataSize() << " synchronising data" << std::endl;
+    //COUT(5) << "Synchronisable: objectID_ " << syncHeader.getObjectID() << ", classID_ " << syncHeader.getClassID() << " size: " << syncHeader.getDataSize() << " synchronising data" << std::endl;
     for(i=syncList.begin(); i!=syncList.end(); i++)
+    {
 …
     if(mode==0x0)
       mode=state_;
     return ( (objectMode_&mode)!=0 && (!syncList.empty() ) );
+  }
   /**
    * This function looks at the header located in the bytestream and checks wheter objectID and classID match with the Synchronisables ones
+    return ( (this->objectMode_ & mode)!=0 && (!syncList.empty() ) );
+  }
+  /**
+   * This function looks at the header located in the bytestream and checks wheter objectID_ and classID_ match with the Synchronisables ones
    * @param mem pointer to the bytestream
    */
 …
+  {
     SynchronisableHeader header(mem);
     assert(header.getObjectID()==this->objectID);
+    assert(header.getObjectID()==this->objectID_);
     return header.isDataAvailable();
+  }
 …
    * @param mode same as in registerVar
    */
   void Synchronisable::setObjectMode(uint8_t mode){
+  void Synchronisable::setSyncMode(uint8_t mode){
     assert(mode==0x0 || mode==0x1 || mode==0x2 || mode==0x3);
     objectMode_=mode;
+    this->objectMode_=mode;
+  }

code/trunk/src/libraries/network/synchronisable/Synchronisable.h

-                      r5781
+                      r5929
    * @brief: stores information about a Synchronisable
+   *
    * This class stores the information about a Synchronisable (objectID, classID, creatorID, dataSize)
+   * This class stores the information about a Synchronisable (objectID_, classID_, creatorID_, dataSize)
    * in an emulated bitset.
    * Bit 1 to 31 store the size of the Data the synchronisable consumes in the stream
    * Bit 32 is a bool and defines whether the data is actually stored or is just filled up with 0
    * Byte 5 to 8: objectID
    * Byte 9 to 12: classID
    * Byte 13 to 16: creatorID
+   * Byte 5 to 8: objectID_
+   * Byte 9 to 12: classID_
+   * Byte 13 to 16: creatorID_
    */
   class _NetworkExport SynchronisableHeader{
 …
       inline uint32_t getObjectID() const
         { return *(uint32_t*)(data_+4); }
       inline void setObjectID(uint32_t objectID)
         { *(uint32_t*)(data_+4) = objectID; }
+      inline void setObjectID(uint32_t objectID_)
+        { *(uint32_t*)(data_+4) = objectID_; }
       inline uint32_t getClassID() const
         { return *(uint32_t*)(data_+8); }
       inline void setClassID(uint32_t classID)
         { *(uint32_t*)(data_+8) = classID; }
+      inline void setClassID(uint32_t classID_)
+        { *(uint32_t*)(data_+8) = classID_; }
       inline uint32_t getCreatorID() const
         { return *(uint32_t*)(data_+12); }
       inline void setCreatorID(uint32_t creatorID)
         { *(uint32_t*)(data_+12) = creatorID; }
+      inline void setCreatorID(uint32_t creatorID_)
+        { *(uint32_t*)(data_+12) = creatorID_; }
       inline void operator=(SynchronisableHeader& h)
         { memcpy(data_, h.data_, getSize()); }
 …
     static Synchronisable *fabricate(uint8_t*& mem, uint8_t mode=0x0);
     static bool deleteObject(uint32_t objectID);
     static Synchronisable *getSynchronisable(uint32_t objectID);
+    static bool deleteObject(uint32_t objectID_);
+    static Synchronisable *getSynchronisable(uint32_t objectID_);
     static unsigned int getNumberOfDeletedObject(){ return deletedObjects_.size(); }
     static uint32_t popDeletedObject(){ uint32_t i = deletedObjects_.front(); deletedObjects_.pop(); return i; }
+    inline uint32_t getObjectID() const {return objectID;}
+    inline unsigned int getCreatorID() const {return creatorID;}
+    inline uint32_t getClassID() const {return classID;}
+    inline unsigned int getPriority() const { return objectFrequency_;}
+    inline uint32_t getObjectID() const {return this->objectID_;}
+    inline unsigned int getCreatorID() const {return this->creatorID_;}
+    inline uint32_t getClassID() const {return this->classID_;}
+    inline unsigned int getPriority() const { return this->objectFrequency_;}
+    inline uint8_t getSyncMode() const { return this->objectMode_; }
+    void setSyncMode(uint8_t mode);
   protected:
 …
     template <class T> void registerVariable(T& variable, uint8_t mode=0x1, NetworkCallbackBase *cb=0, bool bidirectional=false);
     //template <class T> void unregisterVariable(T& var);
-    void setObjectMode(uint8_t mode);
     void setPriority(unsigned int freq){ objectFrequency_ = freq; }
 …
     bool isMyData(uint8_t* mem);
     bool doSync(int32_t id, uint8_t mode=0x0);
+    uint32_t objectID;
+    uint32_t creatorID;
+    uint32_t classID;
+    inline void setObjectID(uint32_t id){ this->objectID_ = id; objectMap_[this->objectID_] = this; }
+    inline void setClassID(uint32_t id){ this->classID_ = id; }
+    uint32_t objectID_;
+    uint32_t creatorID_;
+    uint32_t classID_;
     std::vector<SynchronisableVariableBase*> syncList;

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

-                      r5781
+                      r5929
+ADD_SOURCE_FILES(TOOLS_SRC_FILES
+SET_SOURCE_FILES(TOOLS_SRC_FILES
+COMPILATION_BEGIN ResourceCompilation.cc
+  ResourceCollection.cc
+  ResourceLocation.cc
+COMPILATION_END
+  TextureGenerator.cc
+  Timer.cc
+COMPILATION_BEGIN OgreCompilation.cc
   BillboardSet.cc
   DynamicLines.cc
 …
   Mesh.cc
   ParticleInterface.cc
-  ResourceCollection.cc
-  ResourceLocation.cc
   Shader.cc
+  TextureGenerator.cc
+  Timer.cc
+COMPILATION_END
+)
 ADD_SUBDIRECTORY(interfaces)
 …
 ORXONOX_ADD_LIBRARY(tools
   FIND_HEADER_FILES
-  PCH_FILE
-    ToolsPrecompiledHeaders.h
   DEFINE_SYMBOL
     "TOOLS_SHARED_BUILD"

code/trunk/src/libraries/tools/ResourceLocation.cc

-                      r5781
+                      r5929
 #include "util/Exception.h"
-#include "core/Core.h"
 #include "core/CoreIncludes.h"
+#include "core/PathConfig.h"
 #include "core/XMLFile.h"
 #include "core/XMLPort.h"
 …
         // Find the path
+        boost::filesystem::path path;
+        if (boost::filesystem::exists(Core::getDataPath() / this->getPath()))
+            path = Core::getDataPath() / this->getPath();
+        else if (Core::isDevelopmentRun() && boost::filesystem::exists(Core::getExternalDataPath() / this->getPath()))
+            path = Core::getExternalDataPath() / this->getPath();
+        namespace bf = boost::filesystem;
+        bf::path path;
+        if (bf::exists(PathConfig::getDataPath() / this->getPath()))
+            path = PathConfig::getDataPath() / this->getPath();
+        else if (PathConfig::isDevelopmentRun() && bf::exists(PathConfig::getExternalDataPath() / this->getPath()))
+            path = PathConfig::getExternalDataPath() / this->getPath();
         else
+        {

code/trunk/src/libraries/tools/Timer.cc

-                      r5781
+                      r5929
 #include <set>
+#include "util/Clock.h"
 #include "core/CoreIncludes.h"
 #include "core/ConsoleCommand.h"
 #include "core/CommandExecutor.h"
-#include "core/Clock.h"
 #include "core/Functor.h"
 …
     SetConsoleCommandShortcutExtern(killdelays);
     static std::set<StaticTimer*> delaytimerset;
+    static std::set<Timer*> delaytimerset;
     /**
 …
     void delay(float delay, const std::string& command)
+    {
         StaticTimer *delaytimer = new StaticTimer();
+        Timer* delaytimer = new Timer();
         delaytimerset.insert(delaytimer);
 …
         @param command The command to execute
     */
     void executeDelayedCommand(StaticTimer* timer, const std::string& command)
+    void executeDelayedCommand(Timer* timer, const std::string& command)
+    {
         CommandExecutor::execute(command);
         delete timer;
+        timer->destroy();
         delaytimerset.erase(timer);
+    }
 …
     void killdelays()
+    {
         for (std::set<StaticTimer*>::iterator it = delaytimerset.begin(); it != delaytimerset.end(); ++it)
             delete (*it);
+        for (std::set<Timer*>::iterator it = delaytimerset.begin(); it != delaytimerset.end(); ++it)
+            (*it)->destroy();
         delaytimerset.clear();
 …
         @brief Constructor: Sets the default-values.
     */
+    TimerBase::TimerBase()
+    Timer::Timer()
+    {
+        this->init();
+        RegisterObject(Timer);
+    }
+    /**
+        @brief Constructor: Initializes the Timer with given values.
+        @param interval The timer-interval in seconds
+        @param bLoop If true, the function gets called every 'interval' seconds
+        @param exeuctor A executor of the function to call
+    */
+    Timer::Timer(float interval, bool bLoop, Executor* executor, bool bKillAfterCall)
+    {
+        this->init();
+        RegisterObject(Timer);
+        this->setTimer(interval, bLoop, executor, bKillAfterCall);
+    }
+    /**
+        @brief Deletes the executor.
+    */
+    Timer::~Timer()
+    {
+        this->deleteExecutor();
+    }
+    /**
+        @brief Initializes the Timer
+    */
+    void Timer::init()
+    {
         this->executor_ = 0;
 …
         this->time_ = 0;
-        RegisterObject(TimerBase);
+    }
-    /**
-        @brief Deletes the executor.
-    */
-    TimerBase::~TimerBase()
+    {
-        this->deleteExecutor();
+    }
 …
         @brief Executes the executor.
     */
     void TimerBase::run() const
+    void Timer::run()
+    {
         bool temp = this->bKillAfterCall_; // to avoid errors with bKillAfterCall_=false and an exutors which destroy the timer
 …
         if (temp)
             delete this;
+            this->destroy();
+    }
 …
         @brief Deletes the executor.
     */
     void TimerBase::deleteExecutor()
+    void Timer::deleteExecutor()
+    {
       if (this->executor_)
 …
         @brief Updates the timer before the frames are rendered.
     */
     void TimerBase::tick(const Clock& time)
+    void Timer::tick(const Clock& time)
+    {
         if (this->bActive_)

code/trunk/src/libraries/tools/Timer.h

-                      r5781
+                      r5929
                 ClassName();
                 void functionName();
                 Timer<ClassName> myTimer;
+                Timer myTimer;
         };
 …
         ClassName::ClassName()
+        {
             myTimer.setTimer(interval_in_seconds, bLoop, this, createExecutor(createFunctor(&ClassName::functionName)));
+            myTimer.setTimer(interval_in_seconds, bLoop, createExecutor(createFunctor(&ClassName::functionName, this)));
+        }
 …
 namespace orxonox
+{
-    class StaticTimer;
     void delay(float delay, const std::string& command);
     void killdelays();
     void executeDelayedCommand(StaticTimer* timer, const std::string& command);
+    void executeDelayedCommand(Timer* timer, const std::string& command);
     //! TimerBase is the parent of the Timer class.
     class _ToolsExport TimerBase : public TimeFactorListener
+    //! The Timer is a callback-object, calling a given function after a given time-interval.
+    class _ToolsExport Timer : public TimeFactorListener
+    {
         public:
+            ~TimerBase();
+            Timer();
+            ~Timer();
+            void run() const;
+            Timer(float interval, bool bLoop, Executor* executor, bool bKillAfterCall = false);
+            /**
+                @brief Initializes the Timer with given values.
+                @param interval The timer-interval in seconds
+                @param bLoop If true, the function gets called every 'interval' seconds
+                @param object The object owning the timer and the function
+                @param executor A executor of the function to call
+            */
+            void setTimer(float interval, bool bLoop, Executor* executor, bool bKillAfterCall = false)
+            {
+                this->deleteExecutor();
+                this->setInterval(interval);
+                this->bLoop_ = bLoop;
+                this->executor_ = executor;
+                this->bActive_ = true;
+                this->time_ = this->interval_;
+                this->bKillAfterCall_ = bKillAfterCall;
+            }
+            void run();
             void deleteExecutor();
 …
             void tick(const Clock& time);
         protected:
             TimerBase();
+        private:
+            void init();
             Executor* executor_;  //!< The executor of the function that should be called when the time expires
 …
             long long time_;      //!< Internal variable, counting the time till the next function-call
     };
-    //! The Timer is a callback-object, calling a given function after a given time-interval.
-    template <class T = BaseObject>
-    class Timer : public TimerBase
+    {
-        public:
-            Timer() {}
-            /**
-                @brief Constructor: Initializes the Timer with given values.
-                @param interval The timer-interval in seconds
-                @param bLoop If true, the function gets called every 'interval' seconds
-                @param object The object owning the timer and the function
-                @param exeuctor A executor of the function to call
-            */
-            Timer(float interval, bool bLoop, T* object, ExecutorMember<T>* exeuctor, bool bKillAfterCall = false)
+            {
-                this->setTimer(interval, bLoop, object, exeuctor, bKillAfterCall);
+            }
-            /**
-                @brief Initializes the Timer with given values.
-                @param interval The timer-interval in seconds
-                @param bLoop If true, the function gets called every 'interval' seconds
-                @param object The object owning the timer and the function
-                @param exeuctor A executor of the function to call
-            */
-            void setTimer(float interval, bool bLoop, T* object, ExecutorMember<T>* executor, bool bKillAfterCall = false)
+            {
-                this->deleteExecutor();
-                this->setInterval(interval);
-                this->bLoop_ = bLoop;
-                executor->setObject(object);
-                this->executor_ = static_cast<Executor*>(executor);
-                this->bActive_ = true;
-                this->time_ = this->interval_;
-                this->bKillAfterCall_ = bKillAfterCall;
+            }
-    };
-    //! The StaticTimer is a callback-object, calling a static function after a given time-interval.
-    class _ToolsExport StaticTimer : public TimerBase
+    {
-        public:
-            StaticTimer() {}
-            /**
-                @brief Constructor: Initializes the Timer with given values.
-                @param interval The timer-interval in seconds
-                @param bLoop If true, the function gets called every 'interval' seconds
-                @param exeuctor A executor of the function to call
-            */
-            StaticTimer(float interval, bool bLoop, ExecutorStatic* executor, bool bKillAfterCall = false)
+            {
-                this->setTimer(interval, bLoop, executor, bKillAfterCall);
+            }
-            /**
-                @brief Initializes the Timer with given values.
-                @param interval The timer-interval in seconds
-                @param bLoop If true, the function gets called every 'interval' seconds
-                @param object The object owning the timer and the function
-                @param executor A executor of the function to call
-            */
-            void setTimer(float interval, bool bLoop, ExecutorStatic* executor, bool bKillAfterCall = false)
+            {
-                this->deleteExecutor();
-                this->setInterval(interval);
-                this->bLoop_ = bLoop;
-                this->executor_ = executor;
-                this->bActive_ = true;
-                this->time_ = this->interval_;
-                this->bKillAfterCall_ = bKillAfterCall;
+            }
-    };
+}

code/trunk/src/libraries/tools/ToolsPrereqs.h

-                      r5781
+                      r5929
 /**
+  @file
+  @brief Contains all the necessary forward declarations for all classes and structs.
+@file
+@brief
+    Shared library macros, enums, constants and forward declarations for the tools module
 */
 …
 // Shared library settings
 //-----------------------------------------------------------------------
 #if defined(ORXONOX_PLATFORM_WINDOWS) && !defined(ORXONOX_STATIC_BUILD)
 #  ifdef TOOLS_SHARED_BUILD
 …
 //-----------------------------------------------------------------------
 // Forward declarations
+// Enums
 //-----------------------------------------------------------------------
 …
         };
+    }
+}
+//-----------------------------------------------------------------------
+// Forward declarations
+//-----------------------------------------------------------------------
+namespace orxonox
+{
     class BillboardSet;
     class Mesh;
     class ParticleInterface;
+    class ResourceCollection;
+    class ResourceLocation;
     class Shader;
+    template <class T>
+    class Tickable;
+    class TimeFactorListener;
     class Timer;
-    class StaticTimer;
+}

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

-                      r5781
+                      r5929
 SET_SOURCE_FILES(UTIL_SRC_FILES
-  Clipboard.cc
-  CRC32.cc
   Exception.cc
-  ExprParser.cc
   Math.cc
   MultiType.cc
+  Scope.cc
+  StringUtils.cc
+COMPILATION_BEGIN StableCompilation.cc
+  Clipboard.cc
+  Clock.cc
+  CRC32.cc
+  ExprParser.cc
   OutputBuffer.cc
   OutputHandler.cc
-  Scope.cc
   SignalHandler.cc
   Sleep.cc
-  StringUtils.cc
   SubString.cc
+COMPILATION_END
+)

code/trunk/src/libraries/util/Scope.h

-                      r5738
+                      r5929
 #include "UtilPrereqs.h"
 #include <cassert>
+#include <map>
 #include <set>
+#include <map>
 #include "Debug.h"
+#include "ScopeGuard.h"
 namespace orxonox
+{
-    namespace ScopeID
+    {
-        /**
-            @brief A list of available scopes for the Scope template.
-        */
-        enum Value
+        {
-            GSRoot,
-            GSGraphics,
-            GSLevel
-        };
+    }
-    class ScopeListener; // Forward declaration
     /**
         @brief The ScopeManager stores the variables of the scope templates in a statically linked context.
 …
         protected:
             //! Constructor: Registers the instance.
             ScopeListener(ScopeID::Value scope) : scope_(scope)
+            ScopeListener(ScopeID::Value scope) : scope_(scope), bActivated_(false)
                 { ScopeManager::listeners_s[this->scope_].insert(this); }
             //! Destructor: Unregisters the instance.
 …
         private:
             ScopeID::Value scope_; //!< Store the scope to unregister on destruction
+            bool bActivated_;
     };
 …
             Scope()
+            {
+                ScopeManager::instanceCounts_s[scope]++;
+                assert(ScopeManager::instanceCounts_s[scope] > 0);
+                if (ScopeManager::instanceCounts_s[scope] == 1)
+                try
+                {
+                    for (typename std::set<ScopeListener*>::iterator it = ScopeManager::listeners_s[scope].begin(); it != ScopeManager::listeners_s[scope].end(); )
+                        (*(it++))->activated();
+                    ScopeManager::instanceCounts_s[scope]++;
+                    assert(ScopeManager::instanceCounts_s[scope] > 0);
+                    if (ScopeManager::instanceCounts_s[scope] == 1)
+                    {
+                        Loki::ScopeGuard deactivator = Loki::MakeObjGuard(*this, &Scope::deactivateListeners);
+                        for (typename std::set<ScopeListener*>::iterator it = ScopeManager::listeners_s[scope].begin(); it != ScopeManager::listeners_s[scope].end(); )
+                        {
+                            (*it)->activated();
+                            (*(it++))->bActivated_ = true;
+                        }
+                        deactivator.Dismiss();
+                    }
+                }
+                catch (...)
+                {
+                    ScopeManager::instanceCounts_s[scope]--;
+                    throw;
+                }
+            }
 …
                 if (ScopeManager::instanceCounts_s[scope] == 0)
+                    this->deactivateListeners();
+            }
+            void deactivateListeners()
+            {
+                for (typename std::set<ScopeListener*>::iterator it = ScopeManager::listeners_s[scope].begin(); it != ScopeManager::listeners_s[scope].end(); )
+                {
+                    for (typename std::set<ScopeListener*>::iterator it = ScopeManager::listeners_s[scope].begin(); it != ScopeManager::listeners_s[scope].end(); )
+                        (*(it++))->deactivated();
+                    if ((*it)->bActivated_)
+                    {
+                        try
+                            { (*it)->deactivated(); }
+                        catch (...)
+                            { COUT(0) << "ScopeListener::deactivated() failed! This MUST NOT happen, fix it!" << std::endl; }
+                        (*(it++))->bActivated_ = false;
+                    }
+                    else
+                        ++it;
+                }
+            }

code/trunk/src/libraries/util/Singleton.h

-                      r5738
+                      r5929
+        }
+        //! Update method called by ClassSingletonManager (if used)
+        void updateSingleton(const Clock& time) { static_cast<T*>(T::singletonPtr_s)->update(time); }
+        //! Empty update method for the static polymorphism
+        void update(const Clock& time) { }
     protected:
         //! Constructor sets the singleton instance pointer

code/trunk/src/libraries/util/UtilPrereqs.h

-                      r5738
+                      r5929
 /**
+  @file
+  @brief Contains all the necessary forward declarations for all classes and structs.
+@file
+@brief
+    Shared library macros, enums, constants and forward declarations for the util library
 */
 …
 // Shared library settings
 //-----------------------------------------------------------------------
 #if defined(ORXONOX_PLATFORM_WINDOWS) && !defined( UTIL_STATIC_BUILD )
 #  ifdef UTIL_SHARED_BUILD
 …
 #endif
+//-----------------------------------------------------------------------
+// Enums
+//-----------------------------------------------------------------------
+namespace orxonox
+{
+    namespace ScopeID
+    {
+        //!A list of available scopes for the Scope template.
+        enum Value
+        {
+            Root,
+            Graphics
+        };
+    }
+}
 //-----------------------------------------------------------------------
 …
 namespace orxonox
+{
+    class Clock;
     class Exception;
     class ExprParser;
 …
     class OutputBufferListener;
     class OutputHandler;
+    template <ScopeID::Value>
+    class Scope;
+    template <class, ScopeID::Value>
+    class ScopedSingleton;
+    class ScopeListener;
     class SignalHandler;
+    template <class T>
+    class Singleton;
     class SubString;
+}

code/trunk/src/modules/CMakeLists.txt

r5781	r5929
27	27	################ Sub Directories ################
28	28
29		~~ADD_SUBDIRECTORY(gamestates)~~
30	29	ADD_SUBDIRECTORY(objects)
31	30	ADD_SUBDIRECTORY(overlays)

code/trunk/src/modules/objects/Attacher.cc

-                      r5781
+                      r5929
     void Attacher::processEvent(Event& event)
+    {
         for (std::list<WorldEntity*>::iterator it = this->objects_.begin(); it != this->objects_.end(); ++it)
             (*it)->fireEvent(event);
+        if (this->target_)
+            this->target_->processEvent(event);
+    }
 …
         for (ObjectList<WorldEntity>::iterator it = ObjectList<WorldEntity>::begin(); it != ObjectList<WorldEntity>::end(); ++it)
+        {
             if (it->getName() == this->targetname_)
+            {
+                this->target_ = *it;
                 this->attachToParent(*it);
+            }
+        }
+    }

code/trunk/src/modules/objects/ObjectsPrereqs.h

-                      r5781
+                      r5929
 /**
+  @file
+  @brief Contains all the necessary forward declarations for all classes and structs.
+@file
+@brief
+    Shared library macros, enums, constants and forward declarations for the objects module
 */
 …
 #include "OrxonoxConfig.h"
 #include "OrxonoxPrereqs.h"
 …
 // Shared library settings
 //-----------------------------------------------------------------------
 #if defined(ORXONOX_PLATFORM_WINDOWS) && !defined(ORXONOX_STATIC_BUILD)
 #  ifdef OBJECTS_SHARED_BUILD
 …
     // eventsystem
+    class EventDispatcher;
+    class EventFilter;
     class EventListener;
     class EventDispatcher;
+    class EventName;
     class EventTarget;
     // triggers
     class Trigger;
+    class CheckPoint;
     class DistanceTrigger;
     class EventTrigger;
     class CheckPoint;
+    class Trigger;
+}

code/trunk/src/modules/objects/Planet.cc

-                      r5781
+                      r5929
      * @brief Constructor
      */
     Planet::Planet(BaseObject* creator): MovableEntity(creator)
+    Planet::Planet(BaseObject* creator) : MovableEntity(creator)
+    {
         RegisterObject(Planet);
 …
     void Planet::tick(float dt)
+    {
         if(!this->isVisible())
+        if (!this->isVisible())
             return;
 …
+        {
             Camera* activeCamera = CameraManager::getInstance().getActiveCamera();
             if(activeCamera)
+            if (activeCamera)
+            {
                 float distance = this->getPosition().distance( activeCamera->getWorldPosition() );

code/trunk/src/modules/objects/eventsystem/CMakeLists.txt

-                      r5781
+                      r5929
 ADD_SOURCE_FILES(OBJECTS_SRC_FILES
   EventDispatcher.cc
+  EventFilter.cc
   EventListener.cc
+  EventName.cc
   EventTarget.cc
+)

code/trunk/src/modules/objects/eventsystem/EventDispatcher.cc

r5781	r5929
32	32	#include "core/EventIncludes.h"
33	33	#include "core/XMLPort.h"
34		~~#include "EventTarget.h"~~
35	34
36	35	namespace orxonox
…	…
46	45	{
47	46	if (this->isInitialized())
48		for (std::list<~~EventTarge~~t*>::iterator it = this->targets_.begin(); it != this->targets_.end(); ++it)
49		~~delete (*it~~);
	47	for (std::list<BaseObject*>::iterator it = this->targets_.begin(); it != this->targets_.end(); ++it)
	48	(*it)->destroy();
50	49	}
51	50
…	…
54	53	SUPER(EventDispatcher, XMLPort, xmlelement, mode);
55	54
56		XMLPortObject(EventDispatcher, EventTarget, "targets", addTarget, getTarget, xmlelement, mode);
	55	XMLPortObject(EventDispatcher, BaseObject, "targets", addTarget, getTarget, xmlelement, mode);
	56
	57	// since we need event sources mapped to any state, we have to parse XML by ourselves
	58	this->loadAllEventStates(xmlelement, mode, this, Class(EventDispatcher));
57	59	}
58	60
59	61	void EventDispatcher::processEvent(Event& event)
60	62	{
61		for (std::list<~~EventTarge~~t*>::iterator it = this->targets_.begin(); it != this->targets_.end(); ++it)
62		(*it)->~~fire~~Event(event);
	63	for (std::list<BaseObject*>::iterator it = this->targets_.begin(); it != this->targets_.end(); ++it)
	64	(*it)->processEvent(event);
63	65	}
64	66
65		void EventDispatcher::addTarget(~~EventTarge~~t* target)
	67	void EventDispatcher::addTarget(BaseObject* target)
66	68	{
67	69	this->targets_.push_back(target);
68	70	}
69	71
70		~~EventTarge~~t* EventDispatcher::getTarget(unsigned int index) const
	72	BaseObject* EventDispatcher::getTarget(unsigned int index) const
71	73	{
72	74	unsigned int i = 0;
73		for (std::list<~~EventTarge~~t*>::const_iterator it = this->targets_.begin(); it != this->targets_.end(); ++it)
	75	for (std::list<BaseObject*>::const_iterator it = this->targets_.begin(); it != this->targets_.end(); ++it)
74	76	{
75	77	if (i == index)

code/trunk/src/modules/objects/eventsystem/EventDispatcher.h

-                      r5781
+                      r5929
             virtual void processEvent(Event& event);
             void addTarget(EventTarget* target);
             EventTarget* getTarget(unsigned int index) const;
+            void addTarget(BaseObject* target);
+            BaseObject* getTarget(unsigned int index) const;
         private:
             std::list<EventTarget*> targets_;
+            std::list<BaseObject*> targets_;
     };
+}

code/trunk/src/modules/objects/eventsystem/EventListener.cc

-                      r5781
+                      r5929
         this->bActive_ = true;
+        this->fireEvent(event.activate_, event.originator_);
+        this->fireEvent(event.activate_, event.originator_, event.name_);
         this->bActive_ = false;
+    }
 …
         for (ObjectList<BaseObject>::iterator it = ObjectList<BaseObject>::begin(); it != ObjectList<BaseObject>::end(); ++it)
             if (it->getName() == this->eventName_)
                 this->registerAsListener(*it);
+                this->addEventSource(*it, "");
+    }
 …
         if (object->getName() == this->eventName_)
+            this->registerAsListener(object);
+    }
+    void EventListener::registerAsListener(BaseObject* object)
+    {
+        object->registerEventListener(this, "");
+            this->addEventSource(object, "");
+    }
+}

code/trunk/src/modules/objects/eventsystem/EventListener.h

r5781	r5929
54	54	private:
55	55	virtual void loadedNewXMLName(BaseObject* object);
56		~~void registerAsListener(BaseObject* object);~~
57	56
58	57	std::string eventName_;

code/trunk/src/modules/objects/eventsystem/EventTarget.cc

-                      r5781
+                      r5929
 #include "EventTarget.h"
 #include "core/CoreIncludes.h"
+#include "core/XMLPort.h"
 namespace orxonox
 …
+    {
         RegisterObject(EventTarget);
+        this->bActive_ = false;
+    }
 …
+    {
+    }
+    void EventTarget::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
+        SUPER(EventTarget, XMLPort, xmlelement, mode);
+    void EventTarget::changedName()
+        XMLPortParam(EventTarget, "target", setTargetName, getTargetName, xmlelement, mode);
+        // since we need event sources mapped to any state, we have to parse XML by ourselves
+        this->loadAllEventStates(xmlelement, mode, this, Class(EventTarget));
+    }
+    void EventTarget::processEvent(Event& event)
+    {
+        SUPER(EventTarget, changedName);
+        if (this->bActive_)
+        {
+            COUT(2) << "Warning: Detected Event loop in EventTarget \"" << this->getName() << "\"" << std::endl;
+            return;
+        }
+        this->bActive_ = true;
+        this->fireEvent(event);
+        this->bActive_ = false;
+    }
+    void EventTarget::setTargetName(const std::string& name)
+    {
+        this->target_ = name;
         for (ObjectList<BaseObject>::iterator it = ObjectList<BaseObject>::begin(); it != ObjectList<BaseObject>::end(); ++it)
             if (it->getName() == this->getName())
                 this->addAsEvent(*it);
+            if (it->getName() == this->target_)
+                this->addEventTarget(*it);
+    }
     void EventTarget::loadedNewXMLName(BaseObject* object)
+    {
         if (this->getName() == "")
+        if (this->target_ == "")
             return;
         if (object->getName() == this->getName())
             this->addAsEvent(object);
+        if (object->getName() == this->target_)
+            this->addEventTarget(object);
+    }
     void EventTarget::addAsEvent(BaseObject* object)
+    void EventTarget::addEventTarget(BaseObject* object)
+    {
         if (object != static_cast<BaseObject*>(this))
             object->addEvent(this, "");
+            object->addEventSource(this, "");
+    }
+}

code/trunk/src/modules/objects/eventsystem/EventTarget.h

-                      r5781
+                      r5929
             EventTarget(BaseObject* creator);
             virtual ~EventTarget();
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void processEvent(Event& event);
+            virtual void changedName();
+            void setTargetName(const std::string& name);
+            inline const std::string& getTargetName() const
+                { return this->target_; }
         private:
             virtual void loadedNewXMLName(BaseObject* object);
+            void addAsEvent(BaseObject* object);
+            void addEventTarget(BaseObject* object);
+            std::string target_;
+            bool bActive_;
     };
+}

code/trunk/src/modules/objects/triggers/CheckPoint.cc

r5781	r5929
85	85	DistanceTrigger::triggered(bIsTriggered);
86	86
87		Asteroids* gametype = orxonox_cast<Asteroids*>(this->getGametype());
	87	Asteroids* gametype = orxonox_cast<Asteroids*>(this->getGametype().get());
88	88	if (gametype)
89	89	{

code/trunk/src/modules/objects/triggers/EventTrigger.cc

r5781	r5929
47	47	}
48	48
49		void EventTrigger::~~processEvent(Event& event~~)
	49	void EventTrigger::XMLEventPort(Element& xmlelement, XMLPort::Mode mode)
50	50	{
51		SUPER(EventTrigger, ~~processEvent, event~~);
	51	SUPER(EventTrigger, XMLEventPort, xmlelement, mode);
52	52
53		~~ORXONOX_SET_EVENT(EventTrigger, "trigger", trigger, event~~);
	53	XMLPortEventState(EventTrigger, BaseObject, "trigger", trigger, xmlelement, mode);
54	54	}
55	55

code/trunk/src/modules/objects/triggers/EventTrigger.h

r5781	r5929
41	41	virtual ~EventTrigger();
42	42
43		virtual void ~~processEvent(Event& event~~);
	43	virtual void XMLEventPort(Element& xmlelement, XMLPort::Mode mode);
44	44
45	45	inline void trigger(bool bTriggered)

code/trunk/src/modules/objects/triggers/Trigger.cc

r5781	r5929
72	72	}
73	73
74		this->set~~Object~~Mode(0x0);
	74	this->setSyncMode(0x0);
75	75	}
76	76

code/trunk/src/modules/overlays/FadeoutText.cc

r5781	r5929
46	46
47	47	this->bFadingOut_ = false;
48		this->fadeouttimer_.setTimer(3.0f, false, ~~this, createExecutor(createFunctor(&FadeoutText::fadeout~~)));
	48	this->fadeouttimer_.setTimer(3.0f, false, createExecutor(createFunctor(&FadeoutText::fadeout, this)));
49	49	this->fadeouttimer_.stopTimer();
50	50

code/trunk/src/modules/overlays/FadeoutText.h

r5781	r5929
68	68
69	69	bool bFadingOut_;
70		Timer~~<FadeoutText>~~ fadeouttimer_;
	70	Timer fadeouttimer_;
71	71
72	72	float initialAlpha_;

code/trunk/src/modules/overlays/OverlaysPrereqs.h

-                      r5781
+                      r5929
 /**
+  @file
+  @brief Contains all the necessary forward declarations for all classes and structs.
+@file
+@brief
+    Shared library macros, enums, constants and forward declarations for the overlays module
 */
 …
 #include "OrxonoxConfig.h"
+#include "OrxonoxPrereqs.h"
 //-----------------------------------------------------------------------
 // Shared library settings
 //-----------------------------------------------------------------------
 #if defined(ORXONOX_PLATFORM_WINDOWS) && !defined(ORXONOX_STATIC_BUILD)
 #  ifdef OVERLAYS_SHARED_BUILD
 …
 namespace orxonox
+{
+    class BarColour;
+    class FadeoutText;
+    class GUIOverlay;
+    class OverlayText;
+    // debugging
     class DebugFPSText;
     class DebugRTRText;
+    class GUIOverlay;
+    // hud
+    class AnnounceMessage;
+    class BarColour;
+    class ChatOverlay;
+    class DeathMessage;
+    class GametypeStatus;
     class HUDBar;
+    class HUDHealthBar;
     class HUDNavigation;
     class HUDRadar;
     class HUDSpeedBar;
-    class HUDHealthBar;
     class HUDTimer;
-    class OrxonoxOverlay;
-    class OverlayGroup;
-    class OverlayText;
-    class FadeoutText;
-    class GametypeStatus;
-    class AnnounceMessage;
     class KillMessage;
+    class DeathMessage;
+    class TeamBaseMatchScore;
+    class UnderAttackHealthBar;
+    // stats
     class CreateLines;
     class Scoreboard;

code/trunk/src/modules/overlays/hud/ChatOverlay.cc

r5781	r5929
58	58	ChatOverlay::~ChatOverlay()
59	59	{
	60	for (std::set<Timer*>::iterator it = this->timers_.begin(); it != this->timers_.end(); ++it)
	61	delete (*it);
60	62	}
61	63
…	…
87	89	COUT(0) << "Chat: " << text << std::endl;
88	90
89		new Timer<ChatOverlay>(this->displayTime_, false, this, createExecutor(createFunctor(&ChatOverlay::dropMessage)), true);
	91	Timer* timer = new Timer();
	92	this->timers_.insert(timer); // store the timer in a set to destroy it in the destructor
	93	Executor* executor = createExecutor(createFunctor(&ChatOverlay::dropMessage, this));
	94	executor->setDefaultValues(timer);
	95	timer->setTimer(this->displayTime_, false, executor, true);
90	96
91	97	this->updateOverlayText();
92	98	}
93	99
94		void ChatOverlay::dropMessage()
	100	void ChatOverlay::dropMessage(Timer* timer)
95	101	{
96	102	if (this->messages_.size() > 0)
97	103	this->messages_.pop_front();
98	104	this->updateOverlayText();
	105	this->timers_.erase(timer); // the timer destroys itself, but we have to remove it from the set
99	106	}
100	107

code/trunk/src/modules/overlays/hud/ChatOverlay.h

-                      r5781
+                      r5929
         private:
             void updateOverlayText();
             void dropMessage();
+            void dropMessage(Timer* timer);
             float displayTime_;
+            std::set<Timer*> timers_;
     };
+}

code/trunk/src/modules/overlays/hud/HUDBar.cc

r5781	r5929
96	96	{
97	97	if (this->isInitialized())
	98	{
98	99	Ogre::OverlayManager::getSingleton().destroyOverlayElement(this->bar_);
	100	for (std::vector<BarColour*>::const_iterator it = this->barColours_.begin(); it != this->barColours_.end(); )
	101	(*it++)->destroy();
	102	}
99	103	}
100	104

code/trunk/src/modules/overlays/hud/HUDHealthBar.cc

-                      r5781
+                      r5929
+    {
         if (this->isInitialized())
             delete this->textoverlay_;
+            this->textoverlay_->destroy();
+    }
 …
             this->setValue(this->owner_->getHealth() / this->owner_->getInitialHealth());
             this->textoverlay_->setCaption(multi_cast<std::string>(static_cast<int>(this->owner_->getHealth())));
+        }
+        else
+        {
+            this->setValue(0);
+            this->textoverlay_->setCaption("0");
+        }

code/trunk/src/modules/overlays/hud/HUDHealthBar.h

r5781	r5929
111	111
112	112	private:
113		Pawn* owner_;
	113	WeakPtr<Pawn> owner_;
114	114	OverlayText* textoverlay_;
115	115	bool bUseBarColour_;

code/trunk/src/modules/overlays/hud/HUDNavigation.cc

-                      r5781
+                      r5929
 #include "core/CoreIncludes.h"
 #include "core/XMLPort.h"
+#include "Scene.h"
 #include "Radar.h"
 …
         SUPER(HUDNavigation, tick, dt);
+        if (!Radar::getInstance().getFocus())
+        // Get radar
+        Radar* radar = this->getOwner()->getScene()->getRadar();
+        if (!radar->getFocus())
+        {
             this->overlay_->hide();
 …
 */
         // transform to screen coordinates
         Vector3 pos = /*transformationMatrix * */Radar::getInstance().getFocus()->getRVWorldPosition();
+        Vector3 pos = /*transformationMatrix * */radar->getFocus()->getRVWorldPosition();
         bool outOfView;

code/trunk/src/modules/overlays/hud/TeamBaseMatchScore.cc

r5781	r5929
118	118
119	119	if (this->getOwner() && this->getOwner()->getGametype())
120		this->owner_ = orxonox_cast<TeamBaseMatch*>(this->getOwner()->getGametype());
	120	this->owner_ = orxonox_cast<TeamBaseMatch*>(this->getOwner()->getGametype().get());
121	121	else
122	122	this->owner_ = 0;

code/trunk/src/modules/overlays/hud/UnderAttackHealthBar.cc

r5781	r5929
52	52	this->text_->setPickPoint(Vector2(0.5, 0));
53	53
54		this->inittimer_.setTimer(0.0f, false, ~~this, createExecutor(createFunctor(&UnderAttackHealthBar::init~~)));
	54	this->inittimer_.setTimer(0.0f, false, createExecutor(createFunctor(&UnderAttackHealthBar::init, this)));
55	55	}
56	56
…	…
58	58	{
59	59	if (this->isInitialized())
60		~~delete this->text_~~;
	60	this->text_->destroy();
61	61	}
62	62
…	…
78	78	this->owner_ = player;
79	79
80		UnderAttack* ua = orxonox_cast<UnderAttack*>(player->getGametype());
	80	UnderAttack* ua = orxonox_cast<UnderAttack*>(player->getGametype().get());
81	81	if (ua)
82	82	{

code/trunk/src/modules/overlays/hud/UnderAttackHealthBar.h

r5781	r5929
62	62	PlayerInfo* owner_;
63	63	OverlayText* text_;
64		Timer~~<UnderAttackHealthBar>~~ inittimer_;
	64	Timer inittimer_;
65	65	};
66	66	}

code/trunk/src/modules/overlays/stats/CreateLines.cc

-                      r5781
+                      r5929
     CreateLines::~CreateLines()
+    {
         delete this->playerNameText_;
         delete this->scoreText_;
         delete this->deathsText_;
         delete this->background_;
+        this->playerNameText_->destroy();
+        this->scoreText_->destroy();
+        this->deathsText_->destroy();
+        this->background_->destroy();
+    }

code/trunk/src/modules/overlays/stats/Scoreboard.cc

-                      r5781
+                      r5929
+    {
         RegisterObject(Scoreboard);
+    }
+    Scoreboard::~Scoreboard()
+    {
+        while (this->lines_.size() > 0)
+        {
+            // destroy lines
+            delete this->lines_.back();
+            this->lines_.pop_back();
+        }
+    }

code/trunk/src/modules/overlays/stats/Scoreboard.h

r5781	r5929
42	42	public: // functions
43	43	Scoreboard(BaseObject* creator);
44		virtual ~Scoreboard() {}
	44	virtual ~Scoreboard();
45	45
46	46	virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);

code/trunk/src/modules/pong/CMakeLists.txt

-                      r5781
+                      r5929
 SET_SOURCE_FILES(PONG_SRC_FILES
+COMPILATION_BEGIN PongCompilation.cc
   Pong.cc
   PongAI.cc
 …
   PongCenterpoint.cc
   PongScore.cc
+COMPILATION_END
+)
 …
   MODULE
   FIND_HEADER_FILES
-  PCH_FILE
-    PongPrecompiledHeaders.h
-  PCH_NO_DEFAULT
   DEFINE_SYMBOL
     "PONG_SHARED_BUILD"

code/trunk/src/modules/pong/Pong.cc

-                      r5781
+                      r5929
 #include "core/CoreIncludes.h"
+#include "core/EventIncludes.h"
 #include "core/Executor.h"
 #include "PongCenterpoint.h"
 …
 namespace orxonox
+{
+    CreateEventName(PongCenterpoint, right);
+    CreateEventName(PongCenterpoint, left);
     CreateUnloadableFactory(Pong);
 …
         this->setHUDTemplate("PongHUD");
         this->starttimer_.setTimer(1.0, false, this, createExecutor(createFunctor(&Pong::startBall)));
+        this->starttimer_.setTimer(1.0, false, createExecutor(createFunctor(&Pong::startBall, this)));
         this->starttimer_.stopTimer();
 …
             this->ball_->setFieldDimension(this->center_->getFieldDimension());
             this->ball_->setSpeed(0);
+            this->ball_->setAccelerationFactor(this->center_->getBallAccelerationFactor());
             this->ball_->setBatLength(this->center_->getBatLength());
 …
         if (this->ball_)
+        {
             delete this->ball_;
+            this->ball_->destroy();
             this->ball_ = 0;
+        }
 …
         if (this->center_)
+        {
+            this->center_->fireEvent();
+            if (player == this->getRightPlayer())
+                this->center_->fireEvent(FireEventName(PongCenterpoint, right));
+            else if (player == this->getLeftPlayer())
+                this->center_->fireEvent(FireEventName(PongCenterpoint, left));
             if (player)
                 this->gtinfo_.sendAnnounceMessage(player->getName() + " scored");
+                this->gtinfo_->sendAnnounceMessage(player->getName() + " scored");
+        }
 …
             this->ball_->setPosition(Vector3::ZERO);
             this->ball_->setVelocity(Vector3::ZERO);
+            this->ball_->setAcceleration(Vector3::ZERO);
             this->ball_->setSpeed(0);
+        }

code/trunk/src/modules/pong/Pong.h

r5781	r5929
62	62	PongBall* ball_;
63	63	PongBat* bat_[2];
64		Timer~~<Pong>~~ starttimer_;
	64	Timer starttimer_;
65	65	};
66	66	}

code/trunk/src/modules/pong/PongAI.cc

-                      r5781
+                      r5929
         this->ballEndPosition_ = 0;
         this->randomOffset_ = 0;
+        this->bChangedRandomOffset_ = false;
         this->relHysteresisOffset_ = 0.02f;
         this->strength_ = 0.5f;
 …
     PongAI::~PongAI()
+    {
         for (std::list<std::pair<Timer<PongAI>*, char> >::iterator it = this->reactionTimers_.begin(); it != this->reactionTimers_.end(); ++it)
             delete (*it).first;
+        for (std::list<std::pair<Timer*, char> >::iterator it = this->reactionTimers_.begin(); it != this->reactionTimers_.end(); ++it)
+            (*it).first->destroy();
+    }
 …
                 this->ballEndPosition_ = 0;
                 this->randomOffset_ = 0;
+                this->bChangedRandomOffset_ = false;
                 this->calculateRandomOffset();
 …
                 this->bOscillationAvoidanceActive_ = false;
+            }
+            // If the ball is close enough, calculate another random offset to accelerate the ball
+            if (!this->bChangedRandomOffset_)
+            {
+                float timetohit = (-this->ball_->getPosition().x + this->ball_->getFieldDimension().x / 2 * sgn(this->ball_->getVelocity().x)) / this->ball_->getVelocity().x;
+                if (timetohit < 0.05)
+                {
+                    this->bChangedRandomOffset_ = true;
+                    if (rnd() < this->strength_)
+                        this->calculateRandomOffset();
+                }
+            }
             // Move to the predicted end position with an additional offset (to hit the ball with the side of the bat)
 …
         Vector3 position = this->ball_->getPosition();
         Vector3 velocity = this->ball_->getVelocity();
+        Vector3 acceleration = this->ball_->getAcceleration();
         Vector2 dimension = this->ball_->getFieldDimension();
+        // calculate end-height: current height + slope * distance
+        this->ballEndPosition_ = position.z + velocity.z / velocity.x * (-position.x + dimension.x / 2 * sgn(velocity.x));
+        // Calculate bounces
+        for (float limit = 0.35f; limit < this->strength_ || this->strength_ > 0.99f; limit += 0.4f)
+        {
+            // Calculate a random prediction error, based on the vertical speed of the ball and the strength of the AI
+            float randomError = rnd(-1, 1) * dimension.y * (velocity.z / velocity.x / PongBall::MAX_REL_Z_VELOCITY) * (1 - this->strength_);
+            // Bounce from the lower bound
+            if (this->ballEndPosition_ > dimension.y / 2)
+            {
+                // Mirror the predicted position at the upper bound and add some random error
+                this->ballEndPosition_ = dimension.y - this->ballEndPosition_ + randomError;
+                continue;
+            }
+            // Bounce from the upper bound
+            if (this->ballEndPosition_ < -dimension.y / 2)
+            {
+                // Mirror the predicted position at the lower bound and add some random error
+                this->ballEndPosition_ = -dimension.y - this->ballEndPosition_ + randomError;
+                continue;
+            }
+            // No bounce - break
+            break;
+        // Calculate bounces. The number of predicted bounces is limited by the AIs strength
+        for (float limit = -0.05f; limit < this->strength_ || this->strength_ > 0.99f; limit += 0.4f)
+        {
+            // calculate the time until the ball reaches the other side
+            float totaltime = (-position.x + dimension.x / 2 * sgn(velocity.x)) / velocity.x;
+            // calculate wall bounce position (four possible solutions of the equation: pos.z + vel.z*t + acc.z/2*t^2 = +/- dim.z/2)
+            float bouncetime = totaltime;
+            bool bUpperWall = false;
+            if (acceleration.z == 0)
+            {
+                if (velocity.z > 0)
+                {
+                    bUpperWall = true;
+                    bouncetime = (dimension.y/2 - position.z) / velocity.z;
+                }
+                else if (velocity.z < 0)
+                {
+                    bUpperWall = false;
+                    bouncetime = (-dimension.y/2 - position.z) / velocity.z;
+                }
+            }
+            else
+            {
+                // upper wall
+                float temp = velocity.z*velocity.z + 2*acceleration.z*(dimension.y/2 - position.z);
+                if (temp >= 0)
+                {
+                    float t1 = (sqrt(temp) - velocity.z) / acceleration.z;
+                    float t2 = (sqrt(temp) + velocity.z) / acceleration.z * (-1);
+                    if (t1 > 0 && t1 < bouncetime)
+                    {
+                        bouncetime = t1;
+                        bUpperWall = true;
+                    }
+                    if (t2 > 0 && t2 < bouncetime)
+                    {
+                        bouncetime = t2;
+                        bUpperWall = true;
+                    }
+                }
+                // lower wall
+                temp = velocity.z*velocity.z - 2*acceleration.z*(dimension.y/2 + position.z);
+                if (temp >= 0)
+                {
+                    float t1 = (sqrt(temp) - velocity.z) / acceleration.z;
+                    float t2 = (sqrt(temp) + velocity.z) / acceleration.z * (-1);
+                    if (t1 > 0 && t1 < bouncetime)
+                    {
+                        bouncetime = t1;
+                        bUpperWall = false;
+                    }
+                    if (t2 > 0 && t2 < bouncetime)
+                    {
+                        bouncetime = t2;
+                        bUpperWall = false;
+                    }
+                }
+            }
+            if (bouncetime < totaltime)
+            {
+                // Calculate a random prediction error, based on the vertical speed of the ball and the strength of the AI
+                float randomErrorX = rnd(-1, 1) * dimension.y * (velocity.z / velocity.x / PongBall::MAX_REL_Z_VELOCITY) * (1 - this->strength_);
+                float randomErrorZ = rnd(-1, 1) * dimension.y * (velocity.z / velocity.x / PongBall::MAX_REL_Z_VELOCITY) * (1 - this->strength_);
+                // ball bounces after <bouncetime> seconds, update the position and continue
+                velocity.z = velocity.z + acceleration.z * bouncetime;
+                if (bUpperWall)
+                {
+                    position.z = dimension.y / 2;
+                    velocity.z = -fabs(velocity.z) + fabs(randomErrorZ);
+                }
+                else
+                {
+                    position.z = -dimension.y / 2;
+                    velocity.z = fabs(velocity.z) - fabs(randomErrorZ);
+                }
+                position.x = position.x + velocity.x * bouncetime + randomErrorX;
+                this->ballEndPosition_ = position.z;
+            }
+            else
+            {
+                // ball doesn't bounce, calculate the end position and return
+                // calculate end-height: current height + slope * distance incl. acceleration
+                this->ballEndPosition_ = position.z + velocity.z * totaltime + acceleration.z / 2 * totaltime * totaltime;
+                return;
+            }
+        }
+    }
 …
             // Add a new Timer
             Timer<PongAI>* timer = new Timer<PongAI>(delay, false, this, createExecutor(createFunctor(&PongAI::delayedMove)));
             this->reactionTimers_.push_back(std::pair<Timer<PongAI>*, char>(timer, direction));
+            Timer* timer = new Timer(delay, false, createExecutor(createFunctor(&PongAI::delayedMove, this)));
+            this->reactionTimers_.push_back(std::pair<Timer*, char>(timer, direction));
+        }
         else
 …
         // Destroy the timer and remove it from the list
         Timer<PongAI>* timer = this->reactionTimers_.front().first;
         delete timer;
+        Timer* timer = this->reactionTimers_.front().first;
+        timer->destroy();
         this->reactionTimers_.pop_front();

code/trunk/src/modules/pong/PongAI.h

-                      r5781
+                      r5929
             float ballEndPosition_;
             float randomOffset_;
+            bool bChangedRandomOffset_;
             float relHysteresisOffset_;
             float strength_;
             std::list<std::pair<Timer<PongAI>*, char> > reactionTimers_;
+            std::list<std::pair<Timer*, char> > reactionTimers_;
             char movement_;
             char oldMove_;

code/trunk/src/modules/pong/PongBall.cc

-                      r5781
+                      r5929
 #include "gametypes/Gametype.h"
 #include "PongBat.h"
-#include "sound/SoundBase.h"
 namespace orxonox
 …
     const float PongBall::MAX_REL_Z_VELOCITY = 1.5;
+    PongBall::PongBall(BaseObject* creator) : MovableEntity(creator)
+    PongBall::PongBall(BaseObject* creator)
+        : MovableEntity(creator)
+    {
         RegisterObject(PongBall);
         this->speed_ = 0;
+        this->accelerationFactor_ = 1.0f;
         this->bat_ = 0;
         this->batID_ = new unsigned int[2];
 …
         this->registerVariables();
+    }
+        this->sidesound_ = new SoundBase(this);
+        this->sidesound_->loadFile("sounds/pong_side.wav");
+        this->batsound_ = new SoundBase(this);
+        this->batsound_->loadFile("sounds/pong_bat.wav");
+        this->scoresound_ = new SoundBase(this);
+        this->scoresound_->loadFile("sounds/pong_score.wav");
+    PongBall::~PongBall()
+    {
+    }
 …
         SUPER(PongBall, tick, dt);
+        if (GameMode::isMaster())
+        Vector3 position = this->getPosition();
+        Vector3 velocity = this->getVelocity();
+        Vector3 acceleration = this->getAcceleration();
+        if (position.z > this->fieldHeight_ / 2 || position.z < -this->fieldHeight_ / 2)
+        {
+            Vector3 position = this->getPosition();
+            Vector3 velocity = this->getVelocity();
+            velocity.z = -velocity.z;
+            if (position.z > this->fieldHeight_ / 2)
+                position.z = this->fieldHeight_ / 2;
+            if (position.z < -this->fieldHeight_ / 2)
+                position.z = -this->fieldHeight_ / 2;
+            if (position.z > this->fieldHeight_ / 2 || position.z < -this->fieldHeight_ / 2)
+            this->fireEvent();
+        }
+        if (position.x > this->fieldWidth_ / 2 || position.x < -this->fieldWidth_ / 2)
+        {
+            float distance = 0;
+            if (this->bat_)
+            {
+                velocity.z = -velocity.z;
+                this->sidesound_->play();
+                if (position.z > this->fieldHeight_ / 2)
+                    position.z = this->fieldHeight_ / 2;
+                if (position.z < -this->fieldHeight_ / 2)
+                    position.z = -this->fieldHeight_ / 2;
+            }
+            if (position.x > this->fieldWidth_ / 2 || position.x < -this->fieldWidth_ / 2)
+            {
+                float distance = 0;
+                if (this->bat_)
+                if (position.x > this->fieldWidth_ / 2 && this->bat_[1])
+                {
+                    if (position.x > this->fieldWidth_ / 2 && this->bat_[1])
+                    distance = (position.z - this->bat_[1]->getPosition().z) / (this->fieldHeight_ * (this->batlength_ * 1.10f) / 2);
+                    if (fabs(distance) <= 1)
+                    {
+                        distance = (position.z - this->bat_[1]->getPosition().z) / (this->fieldHeight_ * (this->batlength_ * 1.10f) / 2);
+                        if (fabs(distance) <= 1)
+                        position.x = this->fieldWidth_ / 2;
+                        velocity.x = -velocity.x;
+                        velocity.z = distance * distance * sgn(distance) * PongBall::MAX_REL_Z_VELOCITY * this->speed_;
+                        acceleration = this->bat_[1]->getVelocity() * this->accelerationFactor_ * -1;
+                        this->fireEvent();
+                    }
+                    else if (GameMode::isMaster() && position.x > this->fieldWidth_ / 2 * (1 + this->relMercyOffset_))
+                    {
+                        if (this->getGametype() && this->bat_[0])
+                        {
+                            position.x = this->fieldWidth_ / 2;
+                            velocity.x = -velocity.x;
+                            velocity.z = distance * distance * sgn(distance) * PongBall::MAX_REL_Z_VELOCITY * this->speed_;
+                            this->batsound_->play();
+                        }
+                        else if (position.x > this->fieldWidth_ / 2 * (1 + this->relMercyOffset_))
+                        {
+                            if (this->getGametype() && this->bat_[0])
+                            {
+                                this->getGametype()->playerScored(this->bat_[0]->getPlayer());
+                                this->scoresound_->play();
+                                return;
+                            }
+                            this->getGametype()->playerScored(this->bat_[0]->getPlayer());
+                            return;
+                        }
+                    }
+                    if (position.x < -this->fieldWidth_ / 2 && this->bat_[0])
+                }
+                if (position.x < -this->fieldWidth_ / 2 && this->bat_[0])
+                {
+                    distance = (position.z - this->bat_[0]->getPosition().z) / (this->fieldHeight_ * (this->batlength_ * 1.10f) / 2);
+                    if (fabs(distance) <= 1)
+                    {
+                        distance = (position.z - this->bat_[0]->getPosition().z) / (this->fieldHeight_ * (this->batlength_ * 1.10f) / 2);
+                        if (fabs(distance) <= 1)
+                        position.x = -this->fieldWidth_ / 2;
+                        velocity.x = -velocity.x;
+                        velocity.z = distance * distance * sgn(distance) * PongBall::MAX_REL_Z_VELOCITY * this->speed_;
+                        acceleration = this->bat_[0]->getVelocity() * this->accelerationFactor_ * -1;
+                        this->fireEvent();
+                    }
+                    else if (GameMode::isMaster() && position.x < -this->fieldWidth_ / 2 * (1 + this->relMercyOffset_))
+                    {
+                        if (this->getGametype() && this->bat_[1])
+                        {
+                            position.x = -this->fieldWidth_ / 2;
+                            velocity.x = -velocity.x;
+                            velocity.z = distance * distance * sgn(distance) * PongBall::MAX_REL_Z_VELOCITY * this->speed_;
+                            this->batsound_->play();
+                        }
+                        else if (position.x < -this->fieldWidth_ / 2 * (1 + this->relMercyOffset_))
+                        {
+                            if (this->getGametype() && this->bat_[1])
+                            {
+                                this->scoresound_->play();
+                                this->getGametype()->playerScored(this->bat_[1]->getPlayer());
+                                return;
+                            }
+                            this->getGametype()->playerScored(this->bat_[1]->getPlayer());
+                            return;
+                        }
+                    }
+                }
+            }
+        }
+            if (velocity != this->getVelocity())
+                this->setVelocity(velocity);
+            if (position != this->getPosition())
+                this->setPosition(position);
+        }
+        else
+        {
+          Vector3 position = this->getPosition();
+          Vector3 velocity = this->getVelocity();
+          if (position.z > this->fieldHeight_ / 2 || position.z < -this->fieldHeight_ / 2)
+          {
+            velocity.z = -velocity.z;
+            this->sidesound_->play();
+            if (position.z > this->fieldHeight_ / 2)
+              position.z = this->fieldHeight_ / 2;
+            if (position.z < -this->fieldHeight_ / 2)
+              position.z = -this->fieldHeight_ / 2;
+          }
+          if (position.x > this->fieldWidth_ / 2 || position.x < -this->fieldWidth_ / 2)
+          {
+            float distance = 0;
+            if (this->bat_)
+            {
+              if (position.x > this->fieldWidth_ / 2 && this->bat_[1])
+              {
+                distance = (position.z - this->bat_[1]->getPosition().z) / (this->fieldHeight_ * (this->batlength_ * 1.10f) / 2);
+                if (fabs(distance) <= 1)
+                {
+                  position.x = this->fieldWidth_ / 2;
+                  velocity.x = -velocity.x;
+                  this->batsound_->play();
+                  velocity.z = distance * distance * sgn(distance) * PongBall::MAX_REL_Z_VELOCITY * this->speed_;
+                }
+              }
+              if (position.x < -this->fieldWidth_ / 2 && this->bat_[0])
+              {
+                distance = (position.z - this->bat_[0]->getPosition().z) / (this->fieldHeight_ * (this->batlength_ * 1.10f) / 2);
+                if (fabs(distance) <= 1)
+                {
+                  position.x = -this->fieldWidth_ / 2;
+                  velocity.x = -velocity.x;
+                  this->batsound_->play();
+                  velocity.z = distance * distance * sgn(distance) * PongBall::MAX_REL_Z_VELOCITY * this->speed_;
+                }
+              }
+            }
+          }
+          if (velocity != this->getVelocity())
+        if (acceleration != this->getAcceleration())
+            this->setAcceleration(acceleration);
+        if (velocity != this->getVelocity())
             this->setVelocity(velocity);
           if (position != this->getPosition())
+        if (position != this->getPosition())
             this->setPosition(position);
+        }
+    }

code/trunk/src/modules/pong/PongBall.h

-                      r5781
+                      r5929
         public:
             PongBall(BaseObject* creator);
             virtual ~PongBall() {}
+            virtual ~PongBall();
             virtual void tick(float dt);
 …
                 { return this->speed_; }
+            void setAccelerationFactor(float factor)
+                { this->accelerationFactor_ = factor; }
+            float getAccelerationFactor() const
+                { return this->accelerationFactor_; }
             void setBatLength(float batlength)
                 { this->batlength_ = batlength; }
 …
             float fieldHeight_;
             float speed_;
+            float accelerationFactor_;
             float batlength_;
             PongBat** bat_;
             unsigned int* batID_;
             float relMercyOffset_;
-            SoundBase* sidesound_;
-            SoundBase* batsound_;
-            SoundBase* scoresound_;
     };
+}

code/trunk/src/modules/pong/PongCenterpoint.cc

-                      r5781
+                      r5929
         this->height_ = 120;
         this->ballspeed_ = 100;
+        this->ballaccfactor_ = 1.0;
         this->batspeed_ = 60;
         this->batlength_ = 0.25;
 …
         XMLPortParam(PongCenterpoint, "battemplate", setBattemplate, getBattemplate, xmlelement, mode);
         XMLPortParam(PongCenterpoint, "ballspeed", setBallSpeed, getBallSpeed, xmlelement, mode);
+        XMLPortParam(PongCenterpoint, "ballaccfactor", setBallAccelerationFactor, getBallAccelerationFactor, xmlelement, mode);
         XMLPortParam(PongCenterpoint, "batspeed", setBatSpeed, getBatSpeed, xmlelement, mode);
         XMLPortParam(PongCenterpoint, "batlength", setBatLength, getBatLength, xmlelement, mode);
 …
         if (this->getGametype() && this->getGametype()->isA(Class(Pong)))
+        {
             Pong* pong_gametype = orxonox_cast<Pong*>(this->getGametype());
+            Pong* pong_gametype = orxonox_cast<Pong*>(this->getGametype().get());
             pong_gametype->setCenterpoint(this);
+        }

code/trunk/src/modules/pong/PongCenterpoint.h

-                      r5781
+                      r5929
                 { return this->ballspeed_; }
+            void setBallAccelerationFactor(float ballaccfactor)
+                { this->ballaccfactor_ = ballaccfactor; }
+            float getBallAccelerationFactor() const
+                { return this->ballaccfactor_; }
             void setBatSpeed(float batspeed)
                 { this->batspeed_ = batspeed; }
 …
             float ballspeed_;
+            float ballaccfactor_;
             float batspeed_;
             float batlength_;

code/trunk/src/modules/pong/PongPrereqs.h

-                      r5794
+                      r5929
 /**
+  @file
+  @brief Contains all the necessary forward declarations for all classes and structs.
+@file
+@brief
+    Shared library macros, enums, constants and forward declarations for the pong module
 */
 …
 #include "OrxonoxConfig.h"
+#include "OrxonoxPrereqs.h"
 //-----------------------------------------------------------------------
 // Shared library settings
 //-----------------------------------------------------------------------
 #if defined(ORXONOX_PLATFORM_WINDOWS) && !defined(ORXONOX_STATIC_BUILD)
 #  ifdef PONG_SHARED_BUILD

code/trunk/src/modules/pong/PongScore.cc

r5781	r5929
133	133
134	134	if (this->getOwner() && this->getOwner()->getGametype())
135		this->owner_ = orxonox_cast<Pong*>(this->getOwner()->getGametype());
	135	this->owner_ = orxonox_cast<Pong*>(this->getOwner()->getGametype().get());
136	136	else
137	137	this->owner_ = 0;

code/trunk/src/modules/questsystem/QuestEffectBeacon.cc

-                      r5781
+                      r5929
         XMLPortObject(QuestEffectBeacon, QuestEffect, "effects", addEffect, getEffect, xmlelement, mode);
+        XMLPortEventState(QuestEffectBeacon, PlayerTrigger, "execute", execute, xmlelement, mode);
         COUT(3) << "New QuestEffectBeacon created." << std::endl;
+    }
+    /**
+    @brief
+        Processes an event for this QuestEffectBeacon.
+    */
+    void QuestEffectBeacon::processEvent(Event& event)
+    {
+        SUPER(QuestEffectBeacon, processEvent, event);
+        ORXONOX_SET_SUBCLASS_EVENT(QuestEffectBeacon, "execute", execute, event, PlayerTrigger);
+    void QuestEffectBeacon::XMLEventPort(Element& xmlelement, XMLPort::Mode mode)
+    {
+        SUPER(QuestEffectBeacon, XMLEventPort, xmlelement, mode);
+        XMLPortEventState(QuestEffectBeacon, PlayerTrigger, "execute", execute, xmlelement, mode);
+    }

code/trunk/src/modules/questsystem/QuestEffectBeacon.h

-                      r5781
+                      r5929
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode); //!< Method for creating a QuestEffectBeacon object through XML.
+            virtual void processEvent(Event& event); //!< Processes an event for this QuestEffectBeacon.
+            virtual void XMLEventPort(Element& xmlelement, XMLPort::Mode mode);
             bool execute(bool b, PlayerTrigger* trigger); //!< Executes the QuestEffects of the QuestEffectBeacon.

code/trunk/src/modules/questsystem/QuestGUI.cc

-                      r5781
+                      r5929
         if(this->root_ != NULL)
             delete this->root_;
+            this->root_->destroy();
+    }
 …
             COUT(3) << "Clearing Node '" << *str << "' ..." << std::endl;
             delete str;
             delete node;
+            node->destroy();
+        }
         this->nodes_.clear();

code/trunk/src/modules/questsystem/QuestManager.cc

-                      r5781
+                      r5929
 #include "core/ConsoleCommand.h"
 #include "core/LuaState.h"
+#include "core/ScopedSingletonManager.h"
 #include "infos/PlayerInfo.h"
 #include "overlays/GUIOverlay.h"
 …
     //! Pointer to the current (and single) instance of this class.
     /*static*/ QuestManager* QuestManager::singletonPtr_s = NULL;
+    ManageScopedSingleton(QuestManager, ScopeID::Root, false);
     /**
 …
         for(std::map<PlayerInfo*, QuestGUI*>::iterator it = this->questGUIs_.begin(); it != this->questGUIs_.end(); it++)
+        {
             delete (*it).second;
+            (*it).second->destroy();
+        }
         this->questGUIs_.clear();

code/trunk/src/modules/questsystem/QuestManager.h

-                      r5781
+                      r5929
 #include <string>
 #include "util/ScopedSingleton.h"
+#include "util/Singleton.h"
 #include "core/OrxonoxClass.h"
 …
 namespace orxonox
+{
-    typedef ScopedSingleton<QuestManager, ScopeID::GSLevel> ScopedSingletonQuestManagerGSLevel; // workaround for tolua
     /**
     @brief
 …
         Damian 'Mozork' Frick
     */
+    class _QuestsystemExport QuestManager : public ScopedSingletonQuestManagerGSLevel, public orxonox::OrxonoxClass
+    {
+    class _QuestsystemExport QuestManager
 // tolua_end
+        : public Singleton<QuestManager>, public orxonox::OrxonoxClass
+    { // tolua_export
             friend class ScopedSingleton<QuestManager, ScopeID::GSLevel>;
+            friend class Singleton<QuestManager>;
             friend class QuestGUI;
 …
             //! Returns a reference to the single instance of the Quest Manager.
             static QuestManager& getInstance() { return ScopedSingleton<QuestManager, ScopeID::GSLevel>::getInstance(); } // tolua_export
+            static QuestManager& getInstance() { return Singleton<QuestManager>::getInstance(); } // tolua_export
             //! Retreive the main window for the GUI.

code/trunk/src/modules/questsystem/QuestsystemPrecompiledHeaders.h

-                      r5781
+                      r5929
 #include <OgreColourValue.h> // 16
 #include <tinyxml/ticpp.h>        // 14
 #include "util/ScopedSingleton.h" // 13
+#include <tinyxml/ticpp.h>   // 14
+#include "util/Singleton.h"  // 13
 ///////////////////////////////////////////

code/trunk/src/modules/questsystem/QuestsystemPrereqs.h

-                      r5781
+                      r5929
 /**
+  @file
+  @brief Contains all the necessary forward declarations for all classes and structs.
+@file
+@brief
+    Shared library macros, enums, constants and forward declarations for the questsystem module
 */
 …
 #include "OrxonoxConfig.h"
 #include "OrxonoxPrereqs.h"
 …
 // Shared library settings
 //-----------------------------------------------------------------------
 #if defined(ORXONOX_PLATFORM_WINDOWS) && !defined(ORXONOX_STATIC_BUILD)
 #  ifdef QUESTSYSTEM_SHARED_BUILD
 …
     class QuestEffect;
     class QuestEffectBeacon;
+    class QuestGUI;
     class QuestGUINode;
-    class QuestGUI;
     class QuestHint;
     class QuestItem;
 …
     class QuestManager;
     class QuestNotification;
-    class Rewardable;
+    // notifications
     class Notification;
-    class NotificationListener;
     class NotificationManager;
     class NotificationOverlay;

code/trunk/src/modules/questsystem/notifications/NotificationManager.cc

-                      r5781
+                      r5929
 #include "core/CoreIncludes.h"
+#include "core/ScopedSingletonManager.h"
 #include "Notification.h"
 #include "interfaces/NotificationListener.h"
 …
     NotificationManager* NotificationManager::singletonPtr_s = NULL;
+    ManageScopedSingleton(NotificationManager, ScopeID::Root, false);
     /**

code/trunk/src/modules/questsystem/notifications/NotificationManager.h

-                      r5781
+                      r5929
 #include <string>
 #include "util/ScopedSingleton.h"
+#include "util/Singleton.h"
 #include "core/OrxonoxClass.h"
 namespace orxonox
+{
     /**
     @brief
 …
         Damian 'Mozork' Frick
     */
     class _QuestsystemExport NotificationManager : public ScopedSingleton<NotificationManager, ScopeID::GSLevel>, public OrxonoxClass
+    class _QuestsystemExport NotificationManager : public Singleton<NotificationManager>, public OrxonoxClass
+    {
             friend class ScopedSingleton<NotificationManager, ScopeID::GSLevel>;
+            friend class Singleton<NotificationManager>;
         public:
             NotificationManager();

code/trunk/src/modules/questsystem/notifications/NotificationQueue.cc

r5781	r5929
426	426	this->containers_.erase(container);
427	427	this->overlays_.erase(container->notification);
428		~~delete container->overlay~~;
	428	container->overlay->destroy();
429	429	delete container;
430	430	this->size_= this->size_-1;

code/trunk/src/modules/weapons/MuzzleFlash.cc

-                      r5781
+                      r5929
         RegisterObject(MuzzleFlash);
         this->setScale(0.1f);
-        this->delayTimer_.setTimer(0.1f, false, this, createExecutor(createFunctor(&MuzzleFlash::destroy)));
+        this->delayTimer_.setTimer(0.1f, false, createExecutor(createFunctor(&MuzzleFlash::destroy, this)));
+    }
-    void MuzzleFlash::destroy()
+    {
-        delete this;
+    }
+}

code/trunk/src/modules/weapons/MuzzleFlash.h

-                      r5781
+                      r5929
             virtual ~MuzzleFlash() {}
         private:
+            void destroy();
+            Timer<MuzzleFlash> delayTimer_;
+            Timer delayTimer_;
     };
+}

code/trunk/src/modules/weapons/WeaponsPrereqs.h

-                      r5781
+                      r5929
 /**
+  @file
+  @brief Contains all the necessary forward declarations for all classes and structs.
+@file
+@brief
+    Shared library macros, enums, constants and forward declarations for the weapons module
 */
 …
 #include "OrxonoxConfig.h"
 #include "OrxonoxPrereqs.h"
 …
 // Shared library settings
 //-----------------------------------------------------------------------
 #if defined(ORXONOX_PLATFORM_WINDOWS) && !defined(ORXONOX_STATIC_BUILD)
 #  ifdef WEAPONS_SHARED_BUILD
 …
 namespace orxonox
+{
+    class LaserFire;
+    class MuzzleFlash;
+    // munitions
+    class FusionMunition;
+    class LaserMunition;
+    class ReplenishingMunition;
+    // projectiles
+    class BillboardProjectile;
+    class LightningGunProjectile;
+    class ParticleProjectile;
+    class Projectile;
+    // weaponmodes
+    class EnergyDrink;
     class FusionFire;
     class HsW01;
+    class LaserFire;
     class LightningGun;
-    class EnergyDrink;
-    class Projectile;
-    class BillboardProjectile;
-    class ParticleProjectile;
-    class LightningGunProjectile;
-    class ReplenishingMunition;
-    class LaserMunition;
-    class FusionMunition;
-    class MuzzleFlash;
+}

code/trunk/src/modules/weapons/munitions/ReplenishingMunition.cc

r5781	r5929
44	44	// replenishIntervall_ and replenishMunitionAmount_ will be set in the constructor of the
45	45	// inheriting class, which comes after this constructor)
46		this->replenishingTimer_.setTimer(0.0f, false, ~~this, createExecutor(createFunctor(&ReplenishingMunition::initializeTimer~~)));
	46	this->replenishingTimer_.setTimer(0.0f, false, createExecutor(createFunctor(&ReplenishingMunition::initializeTimer, this)));
47	47	}
48	48
…	…
50	50	{
51	51	// Initialize the timer
52		this->replenishingTimer_.setTimer(this->replenishIntervall_, true, ~~this, createExecutor(createFunctor(&ReplenishingMunition::replenish~~)));
	52	this->replenishingTimer_.setTimer(this->replenishIntervall_, true, createExecutor(createFunctor(&ReplenishingMunition::replenish, this)));
53	53	}
54	54

code/trunk/src/modules/weapons/munitions/ReplenishingMunition.h

r5781	r5929
51	51	void initializeTimer();
52	52
53		Timer~~<ReplenishingMunition>~~ replenishingTimer_;
	53	Timer replenishingTimer_;
54	54	};
55	55	}

code/trunk/src/modules/weapons/projectiles/LightningGunProjectile.cc

r5781	r5929
42	42	this->textureIndex_ = 1;
43	43	this->maxTextureIndex_ = 8;
44		this->textureTimer_.setTimer(0.01f, true, ~~this, createExecutor(createFunctor(&LightningGunProjectile::changeTexture~~)));
	44	this->textureTimer_.setTimer(0.01f, true, createExecutor(createFunctor(&LightningGunProjectile::changeTexture, this)));
45	45
46	46	registerVariables();

code/trunk/src/modules/weapons/projectiles/LightningGunProjectile.h

r5781	r5929
50	50	unsigned int textureIndex_;
51	51	unsigned int maxTextureIndex_;
52		Timer~~<LightningGunProjectile>~~ textureTimer_;
	52	Timer textureTimer_;
53	53	std::string materialBase_;
54	54	private:

code/trunk/src/modules/weapons/projectiles/ParticleProjectile.cc

r5781	r5929
59	59	{
60	60	this->detachOgreObject(this->particles_->getParticleSystem());
61		~~delete this->particles_~~;
	61	this->particles_->destroy();
62	62	}
63	63	}

code/trunk/src/modules/weapons/projectiles/Projectile.cc

r5781	r5929
61	61	this->attachCollisionShape(shape);
62	62
63		this->destroyTimer_.setTimer(this->lifetime_, false, ~~this, createExecutor(createFunctor(&Projectile::destroyObject~~)));
	63	this->destroyTimer_.setTimer(this->lifetime_, false, createExecutor(createFunctor(&Projectile::destroyObject, this)));
64	64	}
65	65	}
…	…
84	84
85	85	if (this->bDestroy_)
86		~~delete this;~~
	86	this->destroy(); // TODO: use a scheduler instead of deleting the object right here in tick()
87	87	}
88	88
…	…
90	90	{
91	91	if (GameMode::isMaster())
92		~~delete this~~;
	92	this->destroy();
93	93	}
94	94
…	…
133	133	}
134	134
135		void Projectile::~~destroyedPawn(Pawn* pawn~~)
	135	void Projectile::setOwner(Pawn* owner)
136	136	{
137		if (this->owner_ == pawn)
138		this->owner_ = 0;
	137	this->owner_ = owner;
139	138	}
140	139	}

code/trunk/src/modules/weapons/projectiles/Projectile.h

-                      r5781
+                      r5929
 #include "tools/Timer.h"
-#include "interfaces/PawnListener.h"
 #include "worldentities/MovableEntity.h"
 namespace orxonox
+{
     class _WeaponsExport Projectile : public MovableEntity, public PawnListener
+    class _WeaponsExport Projectile : public MovableEntity
+    {
         public:
 …
             virtual void tick(float dt);
             virtual bool collidesAgainst(WorldEntity* otherObject, btManifoldPoint& contactPoint);
-            virtual void destroyedPawn(Pawn* pawn);
             inline void setDamage(float damage)
 …
                 { return this->damage_; }
+            inline void setOwner(Pawn* owner)
+                { this->owner_ = owner; }
+            void setOwner(Pawn* owner);
             inline Pawn* getOwner() const
                 { return this->owner_; }
         private:
             Pawn* owner_;
+            WeakPtr<Pawn> owner_;
             float lifetime_;
             float damage_;
             bool bDestroy_;
             Timer<Projectile> destroyTimer_;
+            Timer destroyTimer_;
     };
+}

code/trunk/src/modules/weapons/weaponmodes/EnergyDrink.cc

r5781	r5929
54	54	this->setMunitionName("FusionMunition");
55	55
56		this->delayTimer_.setTimer(1.0f, false, ~~this, createExecutor(createFunctor(&EnergyDrink::shot~~)));
	56	this->delayTimer_.setTimer(1.0f, false, createExecutor(createFunctor(&EnergyDrink::shot, this)));
57	57	this->delayTimer_.stopTimer();
58	58	}

code/trunk/src/modules/weapons/weaponmodes/EnergyDrink.h

r5781	r5929
59	59	float speed_;
60	60	float delay_;
61		Timer~~<EnergyDrink>~~ delayTimer_;
	61	Timer delayTimer_;
62	62	};
63	63	}

code/trunk/src/modules/weapons/weaponmodes/HsW01.cc

r5781	r5929
54	54	this->setMunitionName("LaserMunition");
55	55
56		this->delayTimer_.setTimer(1.0f, false, ~~this, createExecutor(createFunctor(&HsW01::shot~~)));
	56	this->delayTimer_.setTimer(1.0f, false, createExecutor(createFunctor(&HsW01::shot, this)));
57	57	this->delayTimer_.stopTimer();
58	58	}

code/trunk/src/modules/weapons/weaponmodes/HsW01.h

r5781	r5929
57	57	float speed_;
58	58	float delay_;
59		Timer~~<HsW01>~~ delayTimer_;
	59	Timer delayTimer_;
60	60	};
61	61	}

code/trunk/src/orxonox/CMakeLists.txt

-                      r5781
+                      r5929
 SET_SOURCE_FILES(ORXONOX_SRC_FILES
+  Level.cc
+  LevelManager.cc
   Main.cc
-  CameraManager.cc
-  LevelManager.cc
   PawnManager.cc
   PlayerManager.cc
-  Level.cc
   Radar.cc
+COMPILATION_BEGIN SceneCompilation.cc
+  CameraManager.cc
   Scene.cc
+COMPILATION_END
+)
 ADD_SUBDIRECTORY(collisionshapes)
 ADD_SUBDIRECTORY(controllers)
+ADD_SUBDIRECTORY(gamestates)
 ADD_SUBDIRECTORY(gametypes)
 ADD_SUBDIRECTORY(graphics)

code/trunk/src/orxonox/CameraManager.cc

-                      r5781
+                      r5929
+ *
  */
 #include "CameraManager.h"
 …
 #include "util/StringUtils.h"
 #include "core/GameMode.h"
+#include "core/GraphicsManager.h"
 #include "core/GUIManager.h"
 #include "core/ObjectList.h"
+#include "core/ScopedSingletonManager.h"
 #include "tools/Shader.h"
 #include "graphics/Camera.h"
 …
+{
     CameraManager* CameraManager::singletonPtr_s = 0;
+    ManageScopedSingleton(CameraManager, ScopeID::Graphics, false);
     CameraManager::CameraManager(Ogre::Viewport* viewport)
         : viewport_(viewport)
+    CameraManager::CameraManager()
+        : viewport_(GraphicsManager::getInstance().getViewport())
+    {
         this->fallbackCamera_ = 0;
+        assert(GameMode::showsGraphics());
+    }
     CameraManager::~CameraManager()
+    {
+        if (this->fallbackCamera_)
+            this->fallbackCamera_->getSceneManager()->destroyCamera(this->fallbackCamera_);
+        GUIManager::getInstance().setCamera(0);
+    }
     Camera* CameraManager::getActiveCamera() const
+    {
         if (this->cameraList_.size() > 0)
+        if (!this->cameraList_.empty())
             return this->cameraList_.front();
         else
 …
     void CameraManager::requestFocus(Camera* camera)
+    {
-        if (!GameMode::showsGraphics())
-            return;
         // notify old camera (if it exists)
         if (this->cameraList_.size() > 0)
+        if (!this->cameraList_.empty())
             this->cameraList_.front()->removeFocus();
-        else if (this->fallbackCamera_)
+        {
-            this->fallbackCamera_->getSceneManager()->destroyCamera(this->fallbackCamera_);
-            this->fallbackCamera_ = 0;
+        }
         camera->setFocus();
         // make sure we don't add it twice
         for (std::list<Camera*>::iterator it = this->cameraList_.begin(); it != this->cameraList_.end(); ++it)
+        for (std::list<Camera*>::iterator it = this->cameraList_.begin(); it != this->cameraList_.end();)
             if ((*it) == camera)
+                return;
+                this->cameraList_.erase(it++);
+            else
+                ++it;
         // add to list
         this->cameraList_.push_front(camera);
 …
     void CameraManager::releaseFocus(Camera* camera)
+    {
-        if (!GameMode::showsGraphics())
-            return;
         // notify the cam of releasing the focus
         if (this->cameraList_.front() == camera)
+        if (!this->cameraList_.empty() && this->cameraList_.front() == camera)
+        {
             camera->removeFocus();
 …
             // set new focus if possible
             if (this->cameraList_.size() > 0)
+            if (!this->cameraList_.empty())
                 this->cameraList_.front()->setFocus();
-            else
+            {
-                // there are no more cameras, create a fallback
-                if (!this->fallbackCamera_)
-                    this->fallbackCamera_ = camera->getScene()->getSceneManager()->createCamera(getUniqueNumberString());
-                this->useCamera(this->fallbackCamera_);
+            }
+        }
         else
+        {
             this->cameraList_.remove(camera);
+        }
+    }

code/trunk/src/orxonox/CameraManager.h

-                      r5781
+                      r5929
 #include "util/OgreForwardRefs.h"
 #include "util/Singleton.h"
+#include "core/OrxonoxClass.h"
+#include "core/SmartPtr.h"
 namespace orxonox
+{
     class _OrxonoxExport CameraManager : public Singleton<CameraManager>
+    class _OrxonoxExport CameraManager : public Singleton<CameraManager>, public OrxonoxClass
+    {
             friend class Singleton<CameraManager>;
         public:
             CameraManager(Ogre::Viewport* viewport);
+            CameraManager();
             ~CameraManager();
 …
             std::list<Camera*>    cameraList_;
             Ogre::Viewport*       viewport_;
-            Ogre::Camera*         fallbackCamera_;
             static CameraManager* singletonPtr_s;

code/trunk/src/orxonox/Level.cc

-                      r5781
+                      r5929
 #include "util/Math.h"
-#include "core/Core.h"
 #include "core/CoreIncludes.h"
 #include "core/Loader.h"
 …
 #include "gametypes/Gametype.h"
 #include "overlays/OverlayGroup.h"
-#include "sound/SoundBase.h"
 #include "LevelManager.h"
 …
         this->registerVariables();
         this->xmlfilename_ = this->getFilename();
+        this->xmlfile_ = 0;
+    }
 …
             if (this->xmlfile_)
                 Loader::unload(this->xmlfile_);
-            if(this->ambientsound_ != NULL)
-                delete this->ambientsound_;
+        }
+    }
 …
         XMLPortParam(Level, "description", setDescription, getDescription, xmlelement, mode);
         XMLPortParam(Level, "gametype", setGametypeString, getGametypeString, xmlelement, mode).defaultValues("Gametype");
-        XMLPortParamLoadOnly(Level, "ambientsound", loadAmbientSound, xmlelement, mode);
         XMLPortObjectExtended(Level, BaseObject, "", addObject, getObject, xmlelement, mode, true, false);
 …
             this->gametype_ = gametype;
-std::cout << "Load Gametype: " << this->gametype_ << std::endl;
         Gametype* rootgametype = orxonox_cast<Gametype*>(identifier->fabricate(this));
         this->setGametype(rootgametype);
-std::cout << "root gametype: " << rootgametype->getIdentifier()->getName() << std::endl;
         for (std::list<BaseObject*>::iterator it = this->objects_.begin(); it != this->objects_.end(); ++it)
 …
+    }
-    void Level::loadAmbientSound(const std::string& filename)
+    {
-        if(filename == "") return;
-        else
+        {
-            if(this->ambientsound_ == NULL)
+            {
-                this->ambientsound_ = new SoundBase();
+            }
-            this->ambientsound_->loadFile(filename);
-            this->ambientsound_->play(true);
+        }
+    }
     void Level::playerEntered(PlayerInfo* player)
+    {

code/trunk/src/orxonox/Level.h

-                      r5781
+                      r5929
                 { return this->description_; }
-            void loadAmbientSound(const std::string& filename);
             void playerEntered(PlayerInfo* player);
             void playerLeft(PlayerInfo* player);
 …
             XMLFile*               xmlfile_;
             std::list<BaseObject*> objects_;
-            SoundBase*             ambientsound_;
     };
+}

code/trunk/src/orxonox/LevelManager.cc

-                      r5781
+                      r5929
 #include "core/CommandLine.h"
 #include "core/ConfigValueIncludes.h"
-#include "core/Core.h"
 #include "core/CoreIncludes.h"
 #include "core/Loader.h"
+#include "core/ScopedSingletonManager.h"
 #include "PlayerManager.h"
 #include "Level.h"
-#include "infos/HumanPlayer.h"
 namespace orxonox
 …
     LevelManager* LevelManager::singletonPtr_s = 0;
+    ManageScopedSingleton(LevelManager, ScopeID::Root, false);
     LevelManager::LevelManager()

code/trunk/src/orxonox/Main.cc

-                      r5781
+                      r5929
 @file
 @brief
     The main function of Orxonox.
+    The main function of Orxonox (but not the entry point of the program!)
 */
 #include "OrxonoxPrereqs.h"
-#include "SpecialConfig.h"
-#include "util/Exception.h"
 #include "core/CommandLine.h"
 #include "core/Game.h"
 …
 SetCommandLineSwitch(dedicated).information("Start in dedicated server mode");
 SetCommandLineSwitch(standalone).information("Start in standalone mode");
+SetCommandLineSwitch(dedicatedClient).information("Start in dedicated client mode");
 DeclareToluaInterface(Orxonox);
 …
     /**
     @brief
         Main method. Game starts here (except for static initialisations).
+        Starting point of orxonox (however not the entry point of the program!)
     */
     int main(const std::string& strCmdLine)
 …
         " graphics"
         "  mainMenu"
         "  standalone"
+        "  standalone,server,client"
         "   level"
+        "  server"
+        "   level"
+        "  client"
+        "   level"
+        " dedicated"
+        " dedicated,dedicatedClient"
         "  level"
         " ioConsole"
 …
         else if (CommandLine::getValue("dedicated").getBool())
             Game::getInstance().requestStates("dedicated, level");
+        else if (CommandLine::getValue("dedicatedClient").getBool())
+            Game::getInstance().requestStates("dedicatedClient, level");
         else if (CommandLine::getValue("console").getBool())
             Game::getInstance().requestStates("ioConsole");

code/trunk/src/orxonox/OrxonoxPrereqs.h

-                      r5781
+                      r5929
 /**
+  @file
+  @brief Contains all the necessary forward declarations for all classes and structs.
+@file
+@brief
+    Shared library macros, enums, constants and forward declarations for the orxonox library
 */
 …
 #include "OrxonoxConfig.h"
 #include "tools/ToolsPrereqs.h"
 …
 // Shared library settings
 //-----------------------------------------------------------------------
 #if defined(ORXONOX_PLATFORM_WINDOWS) && !defined(ORXONOX_STATIC_BUILD)
 #  ifdef ORXONOX_SHARED_BUILD
 …
+{
     class CameraManager;
+    class Level;
     class LevelManager;
     class PawnManager;
     class PlayerManager;
+    class Level;
+    class Radar;
     class Scene;
+    class Tickable;
+    // collisionshapes
+    class CollisionShape;
+    class CompoundCollisionShape;
+    class WorldEntityCollisionShape;
+    // controllers
+    class AIController;
+    class ArtificialController;
+    class Controller;
+    class HumanController;
+    class ScriptController;
+    class WaypointController;
+    class WaypointPatrolController;
+    // gametypes
+    class Asteroids;
+    class Deathmatch;
+    class Gametype;
+    class TeamBaseMatch;
+    class TeamDeathmatch;
+    class UnderAttack;
+    // graphics
+    class Backlight;
+    class Billboard;
+    class BlinkingBillboard;
+    class Camera;
+    class FadingBillboard;
+    class GlobalShader;
+    class Light;
+    class Model;
+    class ParticleEmitter;
+    class ParticleSpawner;
+    // infos
+    class Bot;
+    class GametypeInfo;
+    class HumanPlayer;
+    class Info;
+    class PlayerInfo;
     // interfaces
     class GametypeMessageListener;
     class NotificationListener;
-    class PawnListener;
     class PlayerTrigger;
     class RadarListener;
     class RadarViewable;
     class Rewardable;
+    class Teamcolourable;
+    // worldentities
+    class WorldEntity;
+    class StaticEntity;
+    class MobileEntity;
+    class ControllableEntity;
+    class MovableEntity;
+    // graphics
+    class Model;
+    class Billboard;
+    class BlinkingBillboard;
+    class BigExplosion;
+    class ExplosionChunk;
+    class FadingBillboard;
+    class GlobalShader;
+    class Light;
+    class Backlight;
+    class ParticleEmitter;
+    class ParticleSpawner;
+    class Camera;
+    // mixed
+    class SpawnPoint;
+    class TeamSpawnPoint;
+    class CameraPosition;
+    class Sublevel;
+    class Radar;
+    class Test;
+    // pawns
+    class Spectator;
+    class Pawn;
+    class SpaceShip;
+    class TeamBaseMatchBase;
+    class Destroyer;
+    // gametypes
+    class Gametype;
+    class Deathmatch;
+    class TeamDeathmatch;
+    class Asteroids;
+    class TeamBaseMatch;
+    class UnderAttack;
+    // pickups
+    class TeamColourable;
+    // items
+    class Engine;
+    class Item;
+    class MultiStateEngine;
+    // overlays
+    class InGameConsole;
+    class Map;
+    class OrxonoxOverlay;
+    class OverlayGroup;
+    // pickup
     class BaseItem;
     class DroppedItem;
 …
     class PickupSpawner;
     class UsableItem;
+    // pickup, items
+    class HealthImmediate;
+    class HealthUsable;
     class Jump;
+    class HealthUsable;
+    class PassiveItem;
+    // items
+    class Item;
+    class Engine;
+    class MultiStateEngine;
+    class RotatingEngine;
+    //sound
+    class AmbientSound;
+    class BaseSound;
+    class SoundManager;
+    class WorldSound;
     // weaponsystem
+    class WeaponSystem;
+    class DefaultWeaponmodeLink;
+    class Munition;
+    class Weapon;
+    class WeaponMode;
+    class WeaponPack;
     class WeaponSet;
     class WeaponSlot;
+    class WeaponPack;
+    class Weapon;
+    class WeaponMode;
+    class DefaultWeaponmodeLink;
+    class Munition;
+    // controller
+    class Controller;
+    class HumanController;
+    class ArtificialController;
+    class AIController;
+    class ScriptController;
+    class WaypointController;
+    class WaypointPatrolController;
+    // infos
+    class Info;
+    class PlayerInfo;
+    class HumanPlayer;
+    class Bot;
+    class GametypeInfo;
+    // collision
+    class CollisionShape;
+    class CompoundCollisionShape;
+    class WorldEntityCollisionShape;
+    // overlays
+    class OverlayGroup;
+    class OrxonoxOverlay;
+    class Notification;
+    class NotificationManager;
+    class InGameConsole;
+    class Map;
+    //sound
+    class SoundBase;
+    class SoundManager;
+    class SoundMainMenu;
+    class WeaponSystem;
+    // worldentities
+    class BigExplosion;
+    class CameraPosition;
+    class ControllableEntity;
+    class ExplosionChunk;
+    class MobileEntity;
+    class MovableEntity;
+    class SpawnPoint;
+    class StaticEntity;
+    class TeamSpawnPoint;
+    class WorldEntity;
+    // worldentities, pawns
+    class Destroyer;
+    class Pawn;
+    class SpaceShip;
+    class Spectator;
+    class TeamBaseMatchBase;
+}

code/trunk/src/orxonox/PawnManager.cc

r5781	r5929
57	57	{
58	58	if (!it->isAlive())
59		~~delete (*(it++)~~);
	59	(it++)->destroy();
60	60	else
61	61	++it;
…	…
63	63
64	64	if (count == 0)
65		~~delete this~~;
	65	this->destroy();
66	66	}
67	67	}

code/trunk/src/orxonox/PlayerManager.cc

-                      r5781
+                      r5929
 #include "core/CoreIncludes.h"
 #include "core/GameMode.h"
+#include "core/ScopedSingletonManager.h"
 #include "Level.h"
 #include "infos/HumanPlayer.h"
 …
+{
     PlayerManager* PlayerManager::singletonPtr_s = 0;
+    ManageScopedSingleton(PlayerManager, ScopeID::Root, false);
     PlayerManager::PlayerManager()
 …
         if (GameMode::isMaster())
+        {
+            COUT(3) << "client disconnected" << std::endl;
+            if (clientID != 0)
+                COUT(3) << "client disconnected" << std::endl;
             // remove from clients-map
 …
             // delete PlayerInfo instance
             if (player)
                 delete player;
+                player->destroy();
+        }
+    }

code/trunk/src/orxonox/PlayerManager.h

-                      r5781
+                      r5929
                 { return this->clients_; }
-        private:
             void clientConnected(unsigned int clientID);
             void clientDisconnected(unsigned int clientID);
+        private:
             std::map<unsigned int, PlayerInfo*> clients_;

code/trunk/src/orxonox/Radar.cc

-                      r5781
+                      r5929
 namespace orxonox
+{
-    SetConsoleCommand(Radar, cycleNavigationFocus, true).accessLevel(AccessLevel::User);
-    SetConsoleCommand(Radar, releaseNavigationFocus, true).accessLevel(AccessLevel::User);
-    Radar* Radar::instance_s = 0;
     Radar::Radar()
 …
         , objectTypeCounter_(0)
+    {
-        assert(instance_s == 0);
-        instance_s = this;
         // TODO: make this mapping configurable. Maybe there's a possibility with self configured
         //       configValues..
 …
     Radar::~Radar()
+    {
-        instance_s = 0;
+    }
     const RadarViewable* Radar::getFocus()
+    {
+        return *(this->itFocus_);
+        if (this->itFocus_)
+            return *(this->itFocus_);
+        else
+            return 0;
+    }
 …
         SUPER(Radar, tick, dt);
         if (this->focus_ != *(this->itFocus_))
+        if (this->itFocus_ && (this->focus_ != *(this->itFocus_)))
+        {
             // focus object was deleted, release focus
 …
+        }
+    }
-    /*static*/ Radar& Radar::getInstance()
+    {
-        assert(instance_s);
-        return *instance_s;
+    }
-    /*static*/ void Radar::cycleNavigationFocus()
+    {
-        // avoid using getInstance because of the assert().
-        // User might call this fuction even if HUDNavigation doesn't exist.
-        if (instance_s)
-            instance_s->cycleFocus();
+    }
-    /*static*/ void Radar::releaseNavigationFocus()
+    {
-        // avoid using getInstance because of the assert().
-        // User might call this fuction even if HUDNavigation doesn't exist.
-        if (instance_s)
-            instance_s->releaseFocus();
+    }
+}

code/trunk/src/orxonox/Radar.h

-                      r5781
+                      r5929
 namespace orxonox
+{
+    /**
+    @brief This class merely ensures that no one can inherit from Radar.
+    */
+    class _OrxonoxExport RadarBase
+    {
+    private:
+        friend class Radar;
+        RadarBase() { }
+    };
+    class _OrxonoxExport Radar : public Tickable, private virtual RadarBase
+    class _OrxonoxExport Radar : public Tickable
+    {
     public:
         Radar();
         ~Radar();
+        virtual ~Radar();
         virtual void tick(float dt);
 …
         void listObjects() const;
+        static Radar& getInstance();
+        static Radar* getInstancePtr() { return instance_s; }
+        static void cycleNavigationFocus();
+        static void releaseNavigationFocus();
+        void releaseFocus();
+        void cycleFocus();
     private:
         Radar(Radar& instance);
-        void releaseFocus();
         void updateFocus();
-        void cycleFocus();
         ObjectListIterator<RadarViewable> itFocus_;
 …
         std::map<std::string, RadarViewable::Shape> objectTypes_;
         int objectTypeCounter_;
-        static Radar* instance_s;
     };
+}

code/trunk/src/orxonox/Scene.cc

-                      r5781
+                      r5929
 #include "core/CoreIncludes.h"
 #include "core/GameMode.h"
+#include "core/GUIManager.h"
 #include "core/XMLPort.h"
 #include "tools/BulletConversions.h"
+#include "Radar.h"
 #include "worldentities/WorldEntity.h"
 …
         RegisterObject(Scene);
         this->setScene(this);
+        this->setScene(SmartPtr<Scene>(this, false), OBJECTID_UNKNOWN);
         this->bShadows_ = true;
 …
             this->sceneManager_ = Ogre::Root::getSingleton().createSceneManager(Ogre::ST_GENERIC);
             this->rootSceneNode_ = this->sceneManager_->getRootSceneNode();
+            this->radar_ = new Radar();
+        }
         else
 …
             this->sceneManager_ = new Ogre::DefaultSceneManager("");
             this->rootSceneNode_ = this->sceneManager_->getRootSceneNode();
+            this->radar_ = 0;
+        }
 …
             else
                 delete this->sceneManager_;
+            if (this->radar_)
+                this->radar_->destroy();
             this->setPhysicalWorld(false);
 …
+    {
         this->objects_.push_back(object);
         object->setScene(this);
+        object->setScene(this, this->getObjectID());
+    }

code/trunk/src/orxonox/Scene.h

-                      r5781
+                      r5929
                 { return this->bShadows_; }
+            inline Radar* getRadar()
+                { return this->radar_; }
+            inline virtual uint32_t getSceneID() const { return this->getObjectID(); }
             virtual void tick(float dt);
 …
             std::list<BaseObject*>   objects_;
             bool                     bShadows_;
+            Radar*                   radar_;

code/trunk/src/orxonox/Test.cc

r5781	r5929
63	63	setConfigValues();
64	64	registerVariables();
65		set~~Object~~Mode(0x3);
	65	setSyncMode(0x3);
66	66	}
67	67

code/trunk/src/orxonox/collisionshapes/CompoundCollisionShape.cc

r5781	r5929
56	56	// make sure that the child doesn't want to detach itself --> speedup because of the missing update
57	57	it->first->notifyDetached();
58		~~delete it->first~~;
	58	it->first->destroy();
59	59	}
60	60

code/trunk/src/orxonox/collisionshapes/WorldEntityCollisionShape.cc

r5781	r5929
43	43	this->worldEntityOwner_ = creator;
44	44	// suppress synchronisation
45		this->set~~Object~~Mode(0x0);
	45	this->setSyncMode(0x0);
46	46	}
47	47

code/trunk/src/orxonox/controllers/AIController.cc

r5781	r5929
44	44	RegisterObject(AIController);
45	45
46		this->actionTimer_.setTimer(ACTION_INTERVAL, true, ~~this, createExecutor(createFunctor(&AIController::action~~)));
	46	this->actionTimer_.setTimer(ACTION_INTERVAL, true, createExecutor(createFunctor(&AIController::action, this)));
47	47	}
48	48

code/trunk/src/orxonox/controllers/AIController.h

r5781	r5929
50	50
51	51	private:
52		Timer~~<AIController>~~ actionTimer_;
	52	Timer actionTimer_;
53	53	};
54	54	}

code/trunk/src/orxonox/controllers/ArtificialController.cc

-                      r5781
+                      r5929
         this->bHasTargetPosition_ = false;
         this->targetPosition_ = Vector3::ZERO;
+        this->target_.setCallback(createFunctor(&ArtificialController::targetDied, this));
+    }
 …
+    }
+    void ArtificialController::destroyedPawn(Pawn* ship)
+    {
+        if (ship == this->target_)
+        {
+            this->forgetTarget();
+            this->searchRandomTargetPosition();
+        }
+    void ArtificialController::abandonTarget(Pawn* target)
+    {
+        if (target == this->target_)
+            this->targetDied();
+    }
+    void ArtificialController::targetDied()
+    {
+        this->forgetTarget();
+        this->searchRandomTargetPosition();
+    }

code/trunk/src/orxonox/controllers/ArtificialController.h

-                      r5781
+                      r5929
 #include "util/Math.h"
-#include "interfaces/PawnListener.h"
 #include "Controller.h"
 namespace orxonox
+{
     class _OrxonoxExport ArtificialController : public Controller, public PawnListener
+    class _OrxonoxExport ArtificialController : public Controller
+    {
         public:
             ArtificialController(BaseObject* creator);
             virtual ~ArtificialController();
             virtual void destroyedPawn(Pawn* pawn);
+            void abandonTarget(Pawn* target);
         protected:
+            void targetDied();
             void moveToPosition(const Vector3& target);
             void moveToTargetPosition();
 …
             bool bHasTargetPosition_;
             Vector3 targetPosition_;
             Pawn* target_;
+            WeakPtr<Pawn> target_;
             bool bShooting_;

code/trunk/src/orxonox/controllers/HumanController.cc

-                      r5781
+                      r5929
 #include "infos/PlayerInfo.h"
 #include "overlays/Map.h"
+#include "graphics/Camera.h"
+#include "sound/SoundManager.h"
+#include "Radar.h"
+#include "Scene.h"
 namespace orxonox
 …
     SetConsoleCommand(HumanController, dropItems,     true);
     SetConsoleCommand(HumanController, useItem,       true);
+    SetConsoleCommand(HumanController, cycleNavigationFocus,   true);
+    SetConsoleCommand(HumanController, releaseNavigationFocus, true);
     CreateUnloadableFactory(HumanController);
 …
+    {
         HumanController::localController_s = 0;
+    }
+    void HumanController::tick(float dt)
+    {
+        if (GameMode::playsSound() && HumanController::localController_s && HumanController::localController_s->controllableEntity_)
+        {
+            // Update sound listener
+            Camera* camera = HumanController::localController_s->controllableEntity_->getCamera();
+            if (camera)
+            {
+                SoundManager::getInstance().setListenerPosition(camera->getWorldPosition());
+                SoundManager::getInstance().setListenerOrientation(camera->getWorldOrientation());
+            }
+            else
+                COUT(3) << "HumanController, Warning: Using a ControllableEntity without Camera" << std::endl;
+        }
+    }
 …
             return NULL;
+    }
+    void HumanController::cycleNavigationFocus()
+    {
+        if (HumanController::localController_s && HumanController::localController_s->controllableEntity_)
+            HumanController::localController_s->controllableEntity_->getScene()->getRadar()->cycleFocus();
+    }
+    void HumanController::releaseNavigationFocus()
+    {
+        if (HumanController::localController_s && HumanController::localController_s->controllableEntity_)
+            HumanController::localController_s->controllableEntity_->getScene()->getRadar()->releaseFocus();
+    }
+}

code/trunk/src/orxonox/controllers/HumanController.h

-                      r5781
+                      r5929
 #include "OrxonoxPrereqs.h"
+#include "tools/interfaces/Tickable.h"
 #include "Controller.h"
 namespace orxonox
+{
     class _OrxonoxExport HumanController : public Controller
+    class _OrxonoxExport HumanController : public Controller, public Tickable
+    {
         public:
             HumanController(BaseObject* creator);
             virtual ~HumanController();
+            virtual void tick(float dt);
             static void moveFrontBack(const Vector2& value);
 …
             static void dropItems();
             static void useItem();
+            static void cycleNavigationFocus();
+            static void releaseNavigationFocus();
             static void suicide();

code/trunk/src/orxonox/controllers/WaypointController.cc

r5781	r5929
50	50	{
51	51	for (size_t i = 0; i < this->waypoints_.size(); ++i)
52		~~delete this->waypoints_[i]~~;
	52	this->waypoints_[i]->destroy();
53	53	}
54	54	}

code/trunk/src/orxonox/controllers/WaypointPatrolController.cc

r5781	r5929
45	45	this->alertnessradius_ = 500;
46	46
47		this->patrolTimer_.setTimer(rnd(), true, ~~this, createExecutor(createFunctor(&WaypointPatrolController::searchEnemy~~)));
	47	this->patrolTimer_.setTimer(rnd(), true, createExecutor(createFunctor(&WaypointPatrolController::searchEnemy, this)));
48	48	}
49	49

code/trunk/src/orxonox/controllers/WaypointPatrolController.h

r5781	r5929
61	61	int team_;
62	62	float alertnessradius_;
63		Timer~~<WaypointPatrolController>~~ patrolTimer_;
	63	Timer patrolTimer_;
64	64	};
65	65	}

code/trunk/src/orxonox/gametypes/Asteroids.cc

r5781	r5929
54	54	if (this->time_ < 0 && !this->hasEnded() && this->timerIsActive_)
55	55	{
56		this->gtinfo_.sendAnnounceMessage("Time's up - you have lost the match!");
	56	this->gtinfo_->sendAnnounceMessage("Time's up - you have lost the match!");
57	57	this->end();
58	58	}
…	…
63	63	if (victim && victim->getPlayer())
64	64	{
65		this->gtinfo_.sendAnnounceMessage("You're dead - you have lost the match!");
	65	this->gtinfo_->sendAnnounceMessage("You're dead - you have lost the match!");
66	66	this->end();
67	67	}

code/trunk/src/orxonox/gametypes/Gametype.cc

-                      r5781
+                      r5929
 #include "core/ConfigValueIncludes.h"
 #include "core/GameMode.h"
+#include "core/ConsoleCommand.h"
 #include "infos/PlayerInfo.h"
 …
     CreateUnloadableFactory(Gametype);
     Gametype::Gametype(BaseObject* creator) : BaseObject(creator), gtinfo_(creator)
+    Gametype::Gametype(BaseObject* creator) : BaseObject(creator)
+    {
         RegisterObject(Gametype);
+        this->setGametype(this);
+        this->gtinfo_ = new GametypeInfo(creator);
+        this->setGametype(SmartPtr<Gametype>(this, false));
         this->defaultControllableEntity_ = Class(Spectator);
 …
         else
             this->scoreboard_ = 0;
+        /* HACK HACK HACK */
+        this->hackAddBots_ = createConsoleCommand( createFunctor(&Gametype::addBots, this), "hackAddBots");
+        this->hackKillBots_ = createConsoleCommand( createFunctor(&Gametype::killBots, this), "hackKillBots");
+        CommandExecutor::addConsoleCommandShortcut( this->hackAddBots_ );
+        CommandExecutor::addConsoleCommandShortcut( this->hackKillBots_ );
+        /* HACK HACK HACK */
+    }
+    Gametype::~Gametype()
+    {
+        if (this->isInitialized())
+        {
+            this->gtinfo_->destroy();
+            if( this->hackAddBots_ )
+                delete this->hackAddBots_;
+            if( this->hackKillBots_ )
+                delete this->hackKillBots_;
+        }
+    }
 …
+        }
         if (this->gtinfo_.bStartCountdownRunning_ && !this->gtinfo_.bStarted_)
             this->gtinfo_.startCountdown_ -= dt;
         if (!this->gtinfo_.bStarted_)
+        if (this->gtinfo_->bStartCountdownRunning_ && !this->gtinfo_->bStarted_)
+            this->gtinfo_->startCountdown_ -= dt;
+        if (!this->gtinfo_->bStarted_)
             this->checkStart();
         else if (!this->gtinfo_.bEnded_)
+        else if (!this->gtinfo_->bEnded_)
             this->spawnDeadPlayersIfRequested();
 …
         this->addBots(this->numberOfBots_);
         this->gtinfo_.bStarted_ = true;
+        this->gtinfo_->bStarted_ = true;
         this->spawnPlayersIfRequested();
 …
     void Gametype::end()
+    {
         this->gtinfo_.bEnded_ = true;
+        this->gtinfo_->bEnded_ = true;
         for (std::map<PlayerInfo*, Player>::iterator it = this->players_.begin(); it != this->players_.end(); ++it)
 …
                 ControllableEntity* oldentity = it->first->getControllableEntity();
                 ControllableEntity* entity = this->defaultControllableEntity_.fabricate(oldentity->getCreator());
+                ControllableEntity* entity = this->defaultControllableEntity_.fabricate(oldentity);
                 if (oldentity->getCamera())
+                {
 …
                         if (killer->getPlayer()->getClientID() != CLIENTID_UNKNOWN)
                             this->gtinfo_.sendKillMessage("You killed " + victim->getPlayer()->getName(), killer->getPlayer()->getClientID());
+                            this->gtinfo_->sendKillMessage("You killed " + victim->getPlayer()->getName(), killer->getPlayer()->getClientID());
                         if (victim->getPlayer()->getClientID() != CLIENTID_UNKNOWN)
                             this->gtinfo_.sendDeathMessage("You were killed by " + killer->getPlayer()->getName(), victim->getPlayer()->getClientID());
+                            this->gtinfo_->sendDeathMessage("You were killed by " + killer->getPlayer()->getName(), victim->getPlayer()->getClientID());
+                    }
+                }
 …
                 it->second.state_ = PlayerState::Dead;
                 if (!it->first->isReadyToSpawn() || !this->gtinfo_.bStarted_)
+                if (!it->first->isReadyToSpawn() || !this->gtinfo_->bStarted_)
+                {
                     this->spawnPlayerAsDefaultPawn(it->first);
 …
     void Gametype::checkStart()
+    {
         if (!this->gtinfo_.bStarted_)
+        {
             if (this->gtinfo_.bStartCountdownRunning_)
+            {
                 if (this->gtinfo_.startCountdown_ <= 0)
+                {
                     this->gtinfo_.bStartCountdownRunning_ = false;
                     this->gtinfo_.startCountdown_ = 0;
+        if (!this->gtinfo_->bStarted_)
+        {
+            if (this->gtinfo_->bStartCountdownRunning_)
+            {
+                if (this->gtinfo_->startCountdown_ <= 0)
+                {
+                    this->gtinfo_->bStartCountdownRunning_ = false;
+                    this->gtinfo_->startCountdown_ = 0;
                     this->start();
+                }
 …
                     if (allplayersready && hashumanplayers)
+                    {
                         this->gtinfo_.startCountdown_ = this->initialStartCountdown_;
                         this->gtinfo_.bStartCountdownRunning_ = true;
+                        this->gtinfo_->startCountdown_ = this->initialStartCountdown_;
+                        this->gtinfo_->bStartCountdownRunning_ = true;
+                    }
+                }
 …
             if (it->getGametype() == this)
+            {
                 delete (*(it++));
+                (it++)->destroy();
                 ++i;
+            }
+            else
+                ++it;
+        }
+    }

code/trunk/src/orxonox/gametypes/Gametype.h

-                      r5781
+                      r5929
 #include "core/BaseObject.h"
 #include "core/Identifier.h"
+#include "core/SubclassIdentifier.h"
 #include "tools/interfaces/Tickable.h"
 #include "infos/GametypeInfo.h"
 …
         public:
             Gametype(BaseObject* creator);
             virtual ~Gametype() {}
+            virtual ~Gametype();
             void setConfigValues();
 …
             inline const GametypeInfo* getGametypeInfo() const
                 { return &this->gtinfo_; }
+                { return this->gtinfo_; }
             inline bool hasStarted() const
                 { return this->gtinfo_.bStarted_; }
+                { return this->gtinfo_->bStarted_; }
             inline bool hasEnded() const
                 { return this->gtinfo_.bEnded_; }
+                { return this->gtinfo_->bEnded_; }
             virtual void start();
 …
             inline bool isStartCountdownRunning() const
                 { return this->gtinfo_.bStartCountdownRunning_; }
+                { return this->gtinfo_->bStartCountdownRunning_; }
             inline float getStartCountdown() const
                 { return this->gtinfo_.startCountdown_; }
+                { return this->gtinfo_->startCountdown_; }
             inline void setHUDTemplate(const std::string& name)
                 { this->gtinfo_.hudtemplate_ = name; }
+                { this->gtinfo_->hudtemplate_ = name; }
             inline const std::string& getHUDTemplate() const
                 { return this->gtinfo_.hudtemplate_; }
+                { return this->gtinfo_->hudtemplate_; }
             void addBots(unsigned int amount);
 …
             virtual void spawnDeadPlayersIfRequested();
             GametypeInfo gtinfo_;
+            SmartPtr<GametypeInfo> gtinfo_;
             bool bAutoStart_;
 …
             // Config Values
             std::string scoreboardTemplate_;
+            /* HACK HACK HACK */
+            ConsoleCommand* hackAddBots_;
+            ConsoleCommand* hackKillBots_;
+            /* HACK HACK HACK */
     };
+}

code/trunk/src/orxonox/gametypes/TeamBaseMatch.cc

r5781	r5929
42	42	RegisterObject(TeamBaseMatch);
43	43
44		this->scoreTimer_.setTimer(10, true, ~~this, createExecutor(createFunctor(&TeamBaseMatch::winPoint~~s)));
45		this->outputTimer_.setTimer(10, true, ~~this, createExecutor(createFunctor(&TeamBaseMatch::showPoint~~s)));
	44	this->scoreTimer_.setTimer(10, true, createExecutor(createFunctor(&TeamBaseMatch::winPoints, this)));
	45	this->outputTimer_.setTimer(10, true, createExecutor(createFunctor(&TeamBaseMatch::showPoints, this)));
46	46
47	47	this->pointsTeam1_ = 0;
…	…
67	67	{
68	68	base->setState(BaseState::ControlTeam1);
69		this->gtinfo_.sendAnnounceMessage("The red team captured a base");
	69	this->gtinfo_->sendAnnounceMessage("The red team captured a base");
70	70	}
71	71	if (teamnr == 1)
72	72	{
73	73	base->setState(BaseState::ControlTeam2);
74		this->gtinfo_.sendAnnounceMessage("The blue team captured a base");
	74	this->gtinfo_->sendAnnounceMessage("The blue team captured a base");
75	75	}
76	76	}
…	…
194	194
195	195	if (it->second == winningteam)
196		this->gtinfo_.sendAnnounceMessage("You have won the match!", it->first->getClientID());
	196	this->gtinfo_->sendAnnounceMessage("You have won the match!", it->first->getClientID());
197	197	else
198		this->gtinfo_.sendAnnounceMessage("You have lost the match!", it->first->getClientID());
	198	this->gtinfo_->sendAnnounceMessage("You have lost the match!", it->first->getClientID());
199	199	}
200	200

code/trunk/src/orxonox/gametypes/TeamBaseMatch.h

-                      r5781
+                      r5929
             std::set<TeamBaseMatchBase*> bases_;
             Timer<TeamBaseMatch> scoreTimer_;
             Timer<TeamBaseMatch> outputTimer_;
+            Timer scoreTimer_;
+            Timer outputTimer_;
             //points for each team

code/trunk/src/orxonox/gametypes/TeamDeathmatch.cc

r5781	r5929
93	93
94	94	if (valid_player)
95		this->~~play~~ers_.erase(player);
	95	this->teamnumbers_.erase(player);
96	96
97	97	return valid_player;
…	…
100	100	bool TeamDeathmatch::allowPawnHit(Pawn* victim, Pawn* originator)
101	101	{
102		return (!this->pawnsAreInTheSameTeam(victim, originator));
	102	return (!this->pawnsAreInTheSameTeam(victim, originator) \|\| !originator);
103	103	}
104	104
105	105	bool TeamDeathmatch::allowPawnDamage(Pawn* victim, Pawn* originator)
106	106	{
107		return (!this->pawnsAreInTheSameTeam(victim, originator));
	107	return (!this->pawnsAreInTheSameTeam(victim, originator) \|\| !originator);
108	108	}
109	109
110	110	bool TeamDeathmatch::allowPawnDeath(Pawn* victim, Pawn* originator)
111	111	{
112		return (!this->pawnsAreInTheSameTeam(victim, originator));
	112	return (!this->pawnsAreInTheSameTeam(victim, originator) \|\| !originator);
113	113	}
114	114

code/trunk/src/orxonox/gametypes/UnderAttack.cc

-                      r5781
+                      r5929
         this->teams_ = 2;
         this->destroyer_ = 0;
+        this->destroyer_.setCallback(createFunctor(&UnderAttack::killedDestroyer, this));
         this->gameEnded_ = false;
 …
     void UnderAttack::destroyedPawn(Pawn* pawn)
+    void UnderAttack::killedDestroyer()
+    {
+        if (pawn == this->destroyer_)
+        this->end(); //end gametype
+        std::string message = "Ship destroyed! Team 0 has won!";
+        COUT(0) << message << std::endl;
+        Host::Broadcast(message);
+        this->gameEnded_ = true;
+        for (std::map<PlayerInfo*, int>::iterator it = this->teamnumbers_.begin(); it != this->teamnumbers_.end(); ++it)
+        {
+            this->end(); //end gametype
+            std::string message = "Ship destroyed! Team 0 has won!";
+            COUT(0) << message << std::endl;
+            Host::Broadcast(message);
+            this->gameEnded_ = true;
+            if (it->first->getClientID() == CLIENTID_UNKNOWN)
+                continue;
+            for (std::map<PlayerInfo*, int>::iterator it = this->teamnumbers_.begin(); it != this->teamnumbers_.end(); ++it)
+            {
+                if (it->first->getClientID() == CLIENTID_UNKNOWN)
+                    continue;
+                if (it->second == 0)
+                    this->gtinfo_.sendAnnounceMessage("You have won the match!", it->first->getClientID());
+                else
+                    this->gtinfo_.sendAnnounceMessage("You have lost the match!", it->first->getClientID());
+            }
+            if (it->second == 0)
+                this->gtinfo_->sendAnnounceMessage("You have won the match!", it->first->getClientID());
+            else
+                this->gtinfo_->sendAnnounceMessage("You have lost the match!", it->first->getClientID());
+        }
+    }
 …
                     if (it->second == 1)
                         this->gtinfo_.sendAnnounceMessage("You have won the match!", it->first->getClientID());
+                        this->gtinfo_->sendAnnounceMessage("You have won the match!", it->first->getClientID());
                     else
                         this->gtinfo_.sendAnnounceMessage("You have lost the match!", it->first->getClientID());
+                        this->gtinfo_->sendAnnounceMessage("You have lost the match!", it->first->getClientID());
+                }
+            }
 …
                 Host::Broadcast(message);
 */
                 this->gtinfo_.sendAnnounceMessage(message);
+                this->gtinfo_->sendAnnounceMessage(message);
                 if (timesequence_ >= 30 && timesequence_ <= 60)

code/trunk/src/orxonox/gametypes/UnderAttack.h

-                      r5781
+                      r5929
 #include "OrxonoxPrereqs.h"
-#include "interfaces/PawnListener.h"
 #include "TeamDeathmatch.h"
 namespace orxonox
+{
     class _OrxonoxExport UnderAttack : public TeamDeathmatch, public PawnListener
+    class _OrxonoxExport UnderAttack : public TeamDeathmatch
+    {
         public:
 …
         protected:
             virtual void destroyedPawn(Pawn* pawn);
+            virtual void killedDestroyer();
             Destroyer* destroyer_;
+            WeakPtr<Destroyer> destroyer_;
             unsigned int teams_;
             float gameTime_;

code/trunk/src/orxonox/graphics/CMakeLists.txt

-                      r5781
+                      r5929
 ADD_SOURCE_FILES(ORXONOX_SRC_FILES
-  Backlight.cc
   Billboard.cc
   BlinkingBillboard.cc
-  Camera.cc
   FadingBillboard.cc
   GlobalShader.cc
-  Light.cc
   Model.cc
   ParticleEmitter.cc
   ParticleSpawner.cc
+COMPILATION_BEGIN GraphicsCompilation.cc
+  Backlight.cc
+  Camera.cc
+  Light.cc
+COMPILATION_END
+)

code/trunk/src/orxonox/graphics/Camera.cc

-                      r5781
+                      r5929
 #include "core/CoreIncludes.h"
 #include "core/ConfigValueIncludes.h"
+#include "core/GameMode.h"
+#include "core/GUIManager.h"
 #include "Scene.h"
 #include "CameraManager.h"
 …
         RegisterObject(Camera);
+        if (!GameMode::showsGraphics())
+            ThrowException(AbortLoading, "Can't create Camera, no graphics.");
         if (!this->getScene())
             ThrowException(AbortLoading, "Can't create Camera, no scene.");
 …
         this->nearClipDistance_ = 1;
         this->setObjectMode(0x0);
+        this->setSyncMode(0x0);
         this->setConfigValues();
 …
         if (this->isInitialized())
+        {
+            if (GUIManager::getInstance().getCamera() == this->camera_)
+                GUIManager::getInstance().setCamera(NULL);
             this->releaseFocus();

code/trunk/src/orxonox/graphics/FadingBillboard.cc

r5781	r5929
103	103	{
104	104	this->changedirection_ = 1;
105		this->turnonofftimer_.setTimer(this->turnontime_, false, ~~this, createExecutor(createFunctor(&FadingBillboard::stopturnonoff~~)));
	105	this->turnonofftimer_.setTimer(this->turnontime_, false, createExecutor(createFunctor(&FadingBillboard::stopturnonoff, this)));
106	106
107	107	if (this->isVisible())
…	…
111	111	{
112	112	this->changedirection_ = -1;
113		this->turnonofftimer_.setTimer(this->turnofftime_, false, ~~this, createExecutor(createFunctor(&FadingBillboard::stopturnonoff~~)));
	113	this->turnonofftimer_.setTimer(this->turnofftime_, false, createExecutor(createFunctor(&FadingBillboard::stopturnonoff, this)));
114	114	}
115	115	}
…	…
126	126	this->fadedColour_ = ColourValue::ZERO;
127	127	this->getBillboardSet().setColour(this->fadedColour_);
128		this->turnonofftimer_.setTimer(this->postprocessingtime_, false, ~~this, createExecutor(createFunctor(&FadingBillboard::poststopturnonoff~~)));
	128	this->turnonofftimer_.setTimer(this->postprocessingtime_, false, createExecutor(createFunctor(&FadingBillboard::poststopturnonoff, this)));
129	129	}
130	130	this->changedirection_ = 0;

code/trunk/src/orxonox/graphics/FadingBillboard.h

r5781	r5929
74	74	float turnofftime_;
75	75	float postprocessingtime_;
76		Timer~~<FadingBillboard>~~ turnonofftimer_;
	76	Timer turnonofftimer_;
77	77	char changedirection_;
78	78	ColourValue fadedColour_;

code/trunk/src/orxonox/graphics/ParticleEmitter.cc

r5781	r5929
63	63	{
64	64	this->detachOgreObject(this->particles_->getParticleSystem());
65		~~delete this->particles_~~;
	65	this->particles_->destroy();
66	66	}
67	67	}
…	…
101	101	if (this->particles_)
102	102	{
103		~~delete this->particles_~~;
	103	this->particles_->destroy();
104	104	this->particles_ = 0;
105	105	}

code/trunk/src/orxonox/graphics/ParticleSpawner.cc

r5781	r5929
71	71	}
72	72
73		void ParticleSpawner::~~processEvent(Event& event~~)
	73	void ParticleSpawner::XMLEventPort(Element& xmlelement, XMLPort::Mode mode)
74	74	{
75		SUPER(ParticleSpawner, ~~processEvent, event~~);
	75	SUPER(ParticleSpawner, XMLEventPort, xmlelement, mode);
76	76
77		~~ORXONOX_SET_EVENT(ParticleSpawner, "spawn", spawn, event~~);
	77	XMLPortEventState(ParticleSpawner, BaseObject, "spawn", spawn, xmlelement, mode);
78	78	}
79	79
…	…
88	88	void ParticleSpawner::startParticleSpawner()
89	89	{
90		~~if (!this->particles_)~~
91		~~return;~~
92
93	90	this->setActive(false);
94	91
95	92	if (this->bForceDestroy_ \|\| this->bSuppressStart_)
	93	{
	94	this->timer_.stopTimer();
96	95	return;
	96	}
97	97
98		this->timer_.setTimer(this->startdelay_, false, ~~this, createExecutor(createFunctor(&ParticleSpawner::fireParticleSpawner~~)));
	98	this->timer_.setTimer(this->startdelay_, false, createExecutor(createFunctor(&ParticleSpawner::fireParticleSpawner, this)));
99	99	}
100	100
…	…
103	103	this->setActive(true);
104	104	if (this->lifetime_ != 0)
105		this->timer_.setTimer(this->lifetime_, false, ~~this, createExecutor(createFunctor(&ParticleSpawner::stopParticleSpawner~~)));
	105	this->timer_.setTimer(this->lifetime_, false, createExecutor(createFunctor(&ParticleSpawner::stopParticleSpawner, this)));
106	106	}
107	107
…	…
116	116
117	117	if (!this->timer_.isActive() \|\| this->timer_.getRemainingTime() > this->destroydelay_)
118		this->timer_.setTimer(this->destroydelay_, false, ~~this, createExecutor(createFunctor(&ParticleSpawner::destroyParticleSpawner~~)));
	118	this->timer_.setTimer(this->destroydelay_, false, createExecutor(createFunctor(&ParticleSpawner::destroyParticleSpawner, this)));
119	119	}
120	120	else if (this->bLoop_)
121	121	{
122		this->timer_.setTimer(this->destroydelay_, false, ~~this, createExecutor(createFunctor(&ParticleSpawner::startParticleSpawner~~)));
	122	this->timer_.setTimer(this->destroydelay_, false, createExecutor(createFunctor(&ParticleSpawner::startParticleSpawner, this)));
123	123	}
124	124	}
…	…
126	126	void ParticleSpawner::destroyParticleSpawner()
127	127	{
128		~~delete this~~;
	128	this->destroy();
129	129	}
130	130	}

code/trunk/src/orxonox/graphics/ParticleSpawner.h

-                      r5781
+                      r5929
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
             virtual void processEvent(Event& event);
+            virtual void XMLEventPort(Element& xmlelement, XMLPort::Mode mode);
             inline void destroy()
                 { this->bForceDestroy_ = true; this->stopParticleSpawner(); }
+            inline void stop(bool bDestroy)
+                { this->bForceDestroy_ = bDestroy; this->stopParticleSpawner(); }
             inline void spawn()
                 { this->bSuppressStart_ = false; this->startParticleSpawner(); }
 …
             void destroyParticleSpawner();
             Timer<ParticleSpawner> timer_;
+            Timer timer_;
             bool  bSuppressStart_;

code/trunk/src/orxonox/infos/HumanPlayer.cc

r5781	r5929
64	64	{
65	65	if (this->humanHud_)
66		~~delete this->humanHud_~~;
	66	this->humanHud_->destroy();
67	67
68	68	if (this->gametypeHud_)
69		~~delete this->gametypeHud_~~;
	69	this->gametypeHud_->destroy();
70	70	}
71	71	}
…	…
116	116
117	117	if (!GameMode::isMaster())
118		this->set~~Object~~Mode(ObjectDirection::Bidirectional);
	118	this->setSyncMode(ObjectDirection::Bidirectional);
119	119	else
120	120	this->setName(this->nick_);
…	…
162	162
163	163	if (this->isInitialized() && this->isLocalPlayer())
164		if (this->getGametype()->getHUDTemplate() != "")
	164	{
	165	if (this->getGametype() && this->getGametype()->getHUDTemplate() != "")
165	166	this->setGametypeHUDTemplate(this->getGametype()->getHUDTemplate());
	167	else
	168	this->setGametypeHUDTemplate("");
	169	}
166	170	}
167	171
…	…
170	174	if (this->humanHud_)
171	175	{
172		~~delete this->humanHud_~~;
	176	this->humanHud_->destroy();
173	177	this->humanHud_ = 0;
174	178	}
175	179
176		if (this->isLocalPlayer() && this->humanHudTemplate_ != "")
	180	if (this->isLocalPlayer() && this->humanHudTemplate_ != "" && GameMode::showsGraphics())
177	181	{
178	182	this->humanHud_ = new OverlayGroup(this);
…	…
186	190	if (this->gametypeHud_)
187	191	{
188		~~delete this->gametypeHud_~~;
	192	this->gametypeHud_->destroy();
189	193	this->gametypeHud_ = 0;
190	194	}

code/trunk/src/orxonox/infos/PlayerInfo.cc

r5781	r5929
35	35	#include "gametypes/Gametype.h"
36	36	#include "worldentities/ControllableEntity.h"
	37	#include "controllers/Controller.h"
37	38
38	39	namespace orxonox
…	…
66	67	if (this->controller_)
67	68	{
68		~~delete this->controller_~~;
	69	this->controller_->destroy();
69	70	this->controller_ = 0;
70	71	}
…	…
131	132	if (this->controller_)
132	133	{
133		~~delete this->controller_~~;
	134	this->controller_->destroy();
134	135	this->controller_ = 0;
135	136	}

code/trunk/src/orxonox/infos/PlayerInfo.h

-                      r5781
+                      r5929
 #include "Info.h"
+#include "core/Identifier.h"
+#include "controllers/Controller.h"
+#include "core/SubclassIdentifier.h"
 namespace orxonox

code/trunk/src/orxonox/interfaces/InterfaceCompilation.cc

-                      r5781
+                      r5929
 #include "GametypeMessageListener.h"
-#include "PawnListener.h"
 #include "PlayerTrigger.h"
 #include "RadarListener.h"
 …
+    {
         RegisterRootObject(GametypeMessageListener);
+    }
-    //----------------------------
-    // PawnListener
-    //----------------------------
-    /**
-        @brief Constructor for the PawnListener.
-    */
-    PawnListener::PawnListener()
+    {
-        RegisterRootObject(PawnListener);
+    }

code/trunk/src/orxonox/interfaces/NotificationListener.h

r5781	r5929
45	45	namespace orxonox
46	46	{
	47	class Notification;
	48
47	49	class _OrxonoxExport NotificationListener : virtual public OrxonoxClass
48	50	{

code/trunk/src/orxonox/interfaces/RadarViewable.cc

-                      r5781
+                      r5929
 #include "worldentities/WorldEntity.h"
 #include "Radar.h"
+#include "Scene.h"
 #include "overlays/Map.h"
 …
     void RadarViewable::setRadarObjectDescription(const std::string& str)
+    {
         Radar* radar = Radar::getInstancePtr();
+        Radar* radar = this->getWorldEntity()->getScene()->getRadar();
         if (radar)
             this->radarObjectShape_ = radar->addObjectDescription(str);

code/trunk/src/orxonox/items/Engine.cc

-                      r5781
+                      r5929
 #include "pickup/ModifierType.h"
 #include "tools/Shader.h"
-#include "sound/SoundBase.h"
 namespace orxonox
 …
         this->setConfigValues();
         this->registerVariables();
-        this->sound_ = NULL;
+    }
 …
             if (this->boostBlur_)
+                delete this->boostBlur_;
+            if(this->sound_ != NULL)
+                delete this->sound_;
+                this->boostBlur_->destroy();
+        }
+    }
 …
         XMLPortParam(Engine, "accelerationleftright", setAccelerationLeftRight, setAccelerationLeftRight, xmlelement, mode);
         XMLPortParam(Engine, "accelerationupdown",    setAccelerationUpDown,    setAccelerationUpDown,    xmlelement, mode);
-        XMLPortParamLoadOnly(Engine, "sound", loadSound, xmlelement, mode);
+    }
 …
             if (this->boostBlur_)
+            {
                 delete this->boostBlur_;
+                this->boostBlur_->destroy();
                 this->boostBlur_ = 0;
+            }
-            if(this->sound_ != NULL)
-                this->sound_->attachToEntity(ship);
+        }
+    }
 …
             return Vector3::ZERO;
+    }
-    void Engine::loadSound(const std::string filename)
+    {
-        if(filename == "") return;
-        else
+        {
-            if(this->sound_ == NULL)
+            {
-                this->sound_ = new SoundBase(this->ship_);
+            }
-            this->sound_->loadFile(filename);
-            this->sound_->play(true);
+        }
+    }
+}

code/trunk/src/orxonox/items/Engine.h

r5781	r5929
130	130	Shader* boostBlur_;
131	131	float blurStrength_;
132
133		~~SoundBase* sound_;~~
134	132	};
135	133	}

code/trunk/src/orxonox/items/MultiStateEngine.cc

-                      r5781
+                      r5929
             // We have no ship, so the effects are not attached and won't be destroyed automatically
             for (std::list<WorldEntity*>::const_iterator it = this->activeEffects_.begin(); it != this->activeEffects_.end(); ++it)
                 delete (*it);
+                (*it)->destroy();
             for (std::list<WorldEntity*>::const_iterator it = this->forwardEffects_.begin(); it != this->forwardEffects_.end(); ++it)
                 delete (*it);
+                (*it)->destroy();
             for (std::list<WorldEntity*>::const_iterator it = this->boostEffects_.begin(); it != this->boostEffects_.end(); ++it)
                 delete (*it);
+                (*it)->destroy();
             for (std::list<WorldEntity*>::const_iterator it = this->brakeEffects_.begin(); it != this->brakeEffects_.end(); ++it)
                 delete (*it);
+                (*it)->destroy();
+        }
+    }
 …
             if (this->getShip()->hasLocalController())
+            {
                 this->setObjectMode(ObjectDirection::Bidirectional);
+                this->setSyncMode(ObjectDirection::Bidirectional);
                 const Vector3& direction = this->getDirection();

code/trunk/src/orxonox/overlays/CMakeLists.txt

-                      r5781
+                      r5929
   OverlayGroup.cc
+COMPILATION_BEGIN OverlayCompilation.cc
   InGameConsole.cc
   Map.cc
+COMPILATION_END
+)

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

-                      r5781
+                      r5929
 #include <OgreFont.h>
+#include "util/Clock.h"
+#include "util/Convert.h"
 #include "util/Math.h"
-#include "util/Convert.h"
 #include "util/UTFStringConversions.h"
-#include "core/Clock.h"
 #include "core/CoreIncludes.h"
 #include "core/ConfigValueIncludes.h"
 #include "core/ConsoleCommand.h"
+#include "core/ScopedSingletonManager.h"
 #include "core/input/InputManager.h"
 #include "core/input/InputState.h"
 …
     InGameConsole* InGameConsole::singletonPtr_s = 0;
+    ManageScopedSingleton(InGameConsole, ScopeID::Graphics, false);
     /**
 …
         this->setConfigValues();
+        this->initialise();
+    }

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

r5781	r5929
50	50
51	51	void initialise();
52		~~void destroy();~~
53	52	void setConfigValues();
54	53

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

-                      r5781
+                      r5929
        for(ObjectList<orxonox::RadarViewable>::iterator it = ObjectList<orxonox::RadarViewable>::begin();
             it!=ObjectList<orxonox::RadarViewable>::end();
             it++)
+            ++it)
+        {
             //COUT(0) << "Radar_Position: " << it->getRVWorldPosition() << std::endl;
 …
         for(ObjectList<orxonox::Map>::iterator it = ObjectList<orxonox::Map>::begin();
             it!=ObjectList<orxonox::Map>::end();
             it++)
+            ++it)
+        {
         //Map * m = it->getMap();

code/trunk/src/orxonox/overlays/OrxonoxOverlay.h

-                      r5781
+                      r5929
   };
   SUPER_FUNCTION(7, OrxonoxOverlay, changedOwner, false);
   SUPER_FUNCTION(8, OrxonoxOverlay, changedOverlayGroup, false);
+  SUPER_FUNCTION(6, OrxonoxOverlay, changedOwner, false);
+  SUPER_FUNCTION(7, OrxonoxOverlay, changedOverlayGroup, false);
+}

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

r5781	r5929
61	61	{
62	62	for (std::set<OrxonoxOverlay*>::iterator it = hudElements_.begin(); it != hudElements_.end(); ++it)
63		~~delete (*it~~);
	63	(*it)->destroy();
64	64	}
65	65

code/trunk/src/orxonox/pickup/DroppedItem.cc

r5781	r5929
56	56	if (this->item_)
57	57	{
58		for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it != ObjectList<Pawn>::end(); ~~it++~~)
	58	for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it != ObjectList<Pawn>::end(); ++it)
59	59	{
60	60	Vector3 distance = it->getWorldPosition() - this->getWorldPosition();
…	…
69	69	{
70	70	COUT(3) << "DroppedItem '" << this->item_->getPickupIdentifier() << "' picked up." << std::endl;
71		~~delete this~~;
	71	this->destroy();
72	72	}
73	73	}
…	…
76	76	if (this->timeToLive_ > 0)
77	77	{
78		ExecutorMember<DroppedItem>* exec = createExecutor(createFunctor(&DroppedItem::timerCallback));
79		this->timer_.setTimer(this->timeToLive_, false, this, exec, false);
	78	this->timer_.setTimer(this->timeToLive_, false, createExecutor(createFunctor(&DroppedItem::timerCallback, this)), false);
80	79	}
81	80	}
…	…
85	84	{
86	85	COUT(3) << "Delete DroppedItem with '" << this->item_->getPickupIdentifier() << "'" << std::endl;
87		~~delete this->item_~~;
	86	this->item_->destroy();
88	87	}
89	88
90		~~delete this~~;
	89	this->destroy();
91	90	}
92	91

code/trunk/src/orxonox/pickup/DroppedItem.h

r5781	r5929
77	77	BaseItem* item_;
78	78
79		Timer~~<DroppedItem>~~ timer_;
	79	Timer timer_;
80	80	};
81	81	}

code/trunk/src/orxonox/pickup/ModifierPickup.cc

-                      r5781
+                      r5929
             if (this->duration_ > 0.0f)
+            {
                 ExecutorMember<ModifierPickup>* executor = createExecutor(createFunctor(&ModifierPickup::timerCallback));
+                Executor* executor = createExecutor(createFunctor(&ModifierPickup::timerCallback, this));
                 executor->setDefaultValues(pawn);
                 this->timer_.setTimer(this->duration_, false, this, executor);
+                this->timer_.setTimer(this->duration_, false, executor);
+            }
 …
                 this->timer_.stopTimer();
             delete this;
+            this->destroy();
             return true;

code/trunk/src/orxonox/pickup/ModifierPickup.h

-                      r5781
+                      r5929
         void timerCallback(Pawn* pawn);     //!< Method called when the timer runs out.
     private:
         float getAdditiveModifier(ModifierType::Value type) const;               //!< Get the additive modifier for a given ModifierType.
 …
         std::map<ModifierType::Value, float> multiplicativeModifiers_;           //!< Map of multiplicative modifiers, indexed by ModifierType.
         float duration_;                                                        //!< Duration of this pickup's effect (0 for unlimited).
         Timer<ModifierPickup> timer_;                                           //!< Timer used if the pickup's effect has a time limit.
+        float duration_;                                                         //!< Duration of this pickup's effect (0 for unlimited).
+        Timer timer_;                                                            //!< Timer used if the pickup's effect has a time limit.
     };
+}

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

r5781	r5929
91	91	asItem->addTemplate(this->itemTemplate_);
92	92	PickupInventory::getImageForItem(asItem);
93		~~delete newObject~~;
	93	newObject->destroy();
94	94	}
95	95
…	…
127	127	if (this->isActive())
128	128	{
129		for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it != ObjectList<Pawn>::end(); ~~it++~~)
	129	for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it != ObjectList<Pawn>::end(); ++it)
130	130	{
131	131	Vector3 distance = it->getWorldPosition() - this->getWorldPosition();
…	…
166	166	if (this->respawnTime_ > 0.0f)
167	167	{
168		ExecutorMember<PickupSpawner>* executor = createExecutor(createFunctor(&PickupSpawner::respawnTimerCallback));
169		this->respawnTimer_.setTimer(this->respawnTime_, false, this, executor);
	168	this->respawnTimer_.setTimer(this->respawnTime_, false, createExecutor(createFunctor(&PickupSpawner::respawnTimerCallback, this)));
170	169
171	170	this->setActive(false);
…	…
174	173	}
175	174	else
176		~~delete newObject~~;
	175	newObject->destroy();
177	176	}
178	177	}

code/trunk/src/orxonox/pickup/PickupSpawner.h

r5781	r5929
114	114
115	115	float respawnTime_; //!< Time after which this gets re-actived.
116		Timer~~<PickupSpawner> respawnTimer_;~~ //!< Timer used for re-activating.
	116	Timer respawnTimer_; //!< Timer used for re-activating.
117	117	};
118	118	}

code/trunk/src/orxonox/pickup/items/HealthImmediate.cc

r5781	r5929
67	67	{
68	68	pawn->addHealth(this->recoveredHealth_);
69		~~delete this~~;
	69	this->destroy();
70	70	}
71	71

code/trunk/src/orxonox/pickup/items/HealthUsable.cc

r5781	r5929
82	82
83	83	this->removeFrom(pawn);
84		~~delete this~~;
	84	this->destroy();
85	85	}
86	86	}

code/trunk/src/orxonox/pickup/items/Jump.cc

r5781	r5929
84	84	{
85	85	this->removeFrom(pawn);
86		~~delete this~~;
	86	this->destroy();
87	87	}
88	88	}

code/trunk/src/orxonox/sound/CMakeLists.txt

-                      r5781
+                      r5929
 ADD_SOURCE_FILES(ORXONOX_SRC_FILES
+    AmbientSound.cc
+    BaseSound.cc
     SoundManager.cc
+    SoundBase.cc
+    SoundMainMenu.cc
+    WorldSound.cc
+)

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

-                      r5781
+                      r5929
 #include <AL/alut.h>
+#include "util/Exception.h"
 #include "util/Math.h"
 #include "CameraManager.h"
 #include "graphics/Camera.h"
 #include "SoundBase.h"
+#include "util/ScopeGuard.h"
+#include "core/GameMode.h"
+#include "core/ScopedSingletonManager.h"
 namespace orxonox
+{
     SoundManager* SoundManager::singletonPtr_s = NULL;
+    ManageScopedSingleton(SoundManager, ScopeID::Graphics, true);
-    /**
-     * Default constructor
-     */
     SoundManager::SoundManager()
+    {
+        this->device_ = NULL;
+        this->soundavailable_ = true;
+        if(!alutInitWithoutContext(NULL,NULL))
+        if (!alutInitWithoutContext(NULL,NULL))
+            ThrowException(InitialisationFailed, "OpenAL ALUT error: " << alutGetErrorString(alutGetError()));
+        Loki::ScopeGuard alutExitGuard = Loki::MakeGuard(&alutExit);
+        COUT(3) << "OpenAL: Opening sound device..." << std::endl;
+        this->device_ = alcOpenDevice(NULL);
+        if (this->device_ == NULL)
+        {
+            COUT(2) << "Sound: OpenAL ALUT: " << alutGetErrorString(alutGetError()) << std::endl;
+            this->soundavailable_ = false;
+            COUT(0) << "OpenaAL: Could not open sound device. Have you installed OpenAL?" << std::endl;
+#ifdef ORXONOX_PLATFORM_WINDOWS
+            COUT(0) << "Just getting the DLL with the dependencies is not enough for Windows (esp. Windows 7)!" << std::endl;
+#endif
+            ThrowException(InitialisationFailed, "OpenAL error: Could not open sound device.");
+        }
+        Loki::ScopeGuard closeDeviceGuard = Loki::MakeGuard(&alcCloseDevice, this->device_);
+        COUT(3) << "OpenAL: Sound device opened" << std::endl;
+        this->context_ = alcCreateContext(this->device_, NULL);
+        if (this->context_ == NULL)
+            ThrowException(InitialisationFailed, "OpenAL error: Could not create sound context");
+        Loki::ScopeGuard desroyContextGuard = Loki::MakeGuard(&alcDestroyContext, this->context_);
+        if (alcMakeContextCurrent(this->context_) == AL_TRUE)
+            COUT(3) << "OpenAL: Context " << this->context_ << " loaded" << std::endl;
+        COUT(4) << "Sound: OpenAL ALUT version: " << alutGetMajorVersion() << "." << alutGetMinorVersion() << std::endl;
+        const char* str = alutGetMIMETypes(ALUT_LOADER_BUFFER);
+        if (str == NULL)
+            COUT(2) << "OpenAL ALUT error: " << alutGetErrorString(alutGetError()) << std::endl;
         else
+        {
+            assert(this->device_ == NULL);
+            COUT(3) << "Sound: OpenAL: Open sound device..." << std::endl;
+            this->device_ = alcOpenDevice(NULL);
+            COUT(4) << "OpenAL ALUT supported MIME types: " << str << std::endl;
+            if(this->device_ == NULL)
+            {
+                COUT(2) << "Sound: OpenAL: Could not open sound device" << std::endl;
+                this->soundavailable_ = false;
+            }
+            else
+            {
+                COUT(3) << "Sound: OpenAL: Sound device opened" << std::endl;
+                this->context_ = alcCreateContext(this->device_, NULL);
+                if(this->context_ == NULL)
+                {
+                    COUT(2) << "Sound: OpenAL: Could not create sound context" << std::endl;
+                    this->soundavailable_ = false;
+                }
+                else
+                {
+                    if(alcMakeContextCurrent(this->context_) == AL_TRUE)
+                        COUT(3) << "Sound: OpenAL: Context " << this->context_ << " loaded" << std::endl;
+                    COUT(4) << "Sound: OpenAL ALUT version: " << alutGetMajorVersion() << "." << alutGetMinorVersion() << std::endl;
+                    const char* str = alutGetMIMETypes(ALUT_LOADER_BUFFER);
+                    if (str == NULL)
+                        COUT(2) << "Sound: OpenAL ALUT: " << alutGetErrorString(alutGetError()) << std::endl;
+                    else
+                        COUT(4) << "Sound: OpenAL ALUT supported MIME types: " << str << std::endl;
+                }
+            }
+        }
+        GameMode::setPlaysSound(true);
+        // Disarm guards
+        alutExitGuard.Dismiss();
+        closeDeviceGuard.Dismiss();
+        desroyContextGuard.Dismiss();
+    }
     SoundManager::~SoundManager()
+    {
+        GameMode::setPlaysSound(false);
         alcDestroyContext(this->context_);
         alcCloseDevice(this->device_);
 …
+    }
+    /**
+     * Add a SoundBase object to the list. Every SoundBase object should be in
+     * this list.
+     *
+     * @param sound Pointer to the SoundBase object to add
+     */
+    void SoundManager::addSound(SoundBase* sound)
+    void SoundManager::setListenerPosition(const Vector3& position)
+    {
+        this->soundlist_.push_back(sound);
+        alListener3f(AL_POSITION, position.x, position.y, position.z);
+        ALenum error = alGetError();
+        if (error == AL_INVALID_VALUE)
+            COUT(2) << "Sound: OpenAL: Invalid listener position" << std::endl;
+    }
+    /**
+     * Remove a SoundBase object from the list and destroy it.
+     */
+    void SoundManager::removeSound(SoundBase* sound)
+    void SoundManager::setListenerOrientation(const Quaternion& orientation)
+    {
+        std::list<SoundBase*>::iterator pos = this->soundlist_.end();
+        for(std::list<SoundBase*>::iterator i = this->soundlist_.begin(); i != this->soundlist_.end(); i++)
+        {
+            if((*i) == sound)
+                pos = i;
+        }
+        // update listener orientation
+        Vector3 up = orientation.xAxis(); // just a wild guess
+        Vector3 at = orientation.zAxis();
+        delete (*pos);
+        this->soundlist_.erase(pos);
+    }
+        ALfloat orient[6] = { at.x, at.y, at.z,
+                              up.x, up.y, up.z };
+    /**
+     * Tick function, updates listener and registred SoundBase objects
+     *
+     * @param dt @see Orxonox::Tickable
+     */
+    void SoundManager::tick(float dt)
+    {
+        if (!CameraManager::getInstancePtr())
+            return;
+        // update listener position
+        Camera* camera = CameraManager::getInstance().getActiveCamera();
+        if(camera == NULL) return;
+        Vector3 pos = camera->getPosition();
+        alListener3f(AL_POSITION, pos.x, pos.y, pos.z);
+        alListenerfv(AL_POSITION, orient);
         ALenum error = alGetError();
+        if(error == AL_INVALID_VALUE)
+            COUT(2) << "Sound: OpenAL: Invalid listener position" << std::endl;
+        // update listener orientation
+        const Quaternion& orient = camera->getOrientation();
+        Vector3 up = orient.xAxis(); // just a wild guess
+        Vector3 at = orient.zAxis();
+        ALfloat orientation[6] = { at.x, at.y, at.z,
+                                 up.x, up.y, up.z };
+        alListenerfv(AL_POSITION, orientation);
+        error = alGetError();
+        if(error == AL_INVALID_VALUE)
+        if (error == AL_INVALID_VALUE)
             COUT(2) << "Sound: OpenAL: Invalid listener orientation" << std::endl;
-        // update sounds
-        for(std::list<SoundBase*>::iterator i = this->soundlist_.begin(); i != this->soundlist_.end(); i++)
-            (*i)->update();
+    }
-    /**
-    * Check if sound is available
-    */
-    bool SoundManager::isSoundAvailable()
+    {
-        return this->soundavailable_;
+    }
+}

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

-                      r5781
+                      r5929
     /**
      * The SoundManager class manages the OpenAL device, context and listener
+     * position. It has a list of all SoundBase objects and calls their update
+     * function every tick. It is a singleton.
+     * position. It is a singleton.
+     *
      */
     class _OrxonoxExport SoundManager : public Singleton<SoundManager>, public Tickable
+    class _OrxonoxExport SoundManager : public Singleton<SoundManager>
+    {
         friend class Singleton<SoundManager>;
 …
         SoundManager();
         ~SoundManager();
+        void addSound(SoundBase* sound);
+        void removeSound(SoundBase* sound);
+        void tick(float dt);
+        bool isSoundAvailable();
+        void setListenerPosition(const Vector3& position);
+        void setListenerOrientation(const Quaternion& orientation);
     private:
         ALCdevice* device_;
         ALCcontext* context_;
-        std::list<SoundBase*> soundlist_;
-        bool soundavailable_;
         static SoundManager* singletonPtr_s;
     }; // class SoundManager
 } // namespace orxonox
+    };
+}
 #endif /* _SoundManager_H__ */

code/trunk/src/orxonox/weaponsystem/Munition.cc

-                      r5781
+                      r5929
         if (bUseReloadTime && (munition->reloadTime_ > 0 || munition->bStackMunition_))
+        {
             ExecutorMember<Magazine>* executor = createExecutor(createFunctor(&Magazine::loaded));
+            Executor* executor = createExecutor(createFunctor(&Magazine::loaded, this));
             executor->setDefaultValues(munition);
             this->loadTimer_.setTimer(munition->reloadTime_, false, this, executor);
+            this->loadTimer_.setTimer(munition->reloadTime_, false, executor);
+        }
         else

code/trunk/src/orxonox/weaponsystem/Munition.h

r5781	r5929
47	47
48	48	unsigned int munition_;
49		Timer~~<Magazine>~~ loadTimer_;
	49	Timer loadTimer_;
50	50	bool bLoaded_;
51	51

code/trunk/src/orxonox/weaponsystem/Weapon.cc

r5781	r5929
50	50	this->reloadingWeaponmode_ = WeaponSystem::WEAPON_MODE_UNASSIGNED;
51	51
52		this->reloadTimer_.setTimer(0.0f, false, ~~this, createExecutor(createFunctor(&Weapon::reloaded~~)));
	52	this->reloadTimer_.setTimer(0.0f, false, createExecutor(createFunctor(&Weapon::reloaded, this)));
53	53	this->reloadTimer_.stopTimer();
54	54	}
…	…
62	62
63	63	for (std::multimap<unsigned int, WeaponMode*>::iterator it = this->weaponmodes_.begin(); it != this->weaponmodes_.end(); ++it)
64		~~delete it->second~~;
	64	it->second->destroy();
65	65	}
66	66	}

code/trunk/src/orxonox/weaponsystem/Weapon.h

r5781	r5929
71	71	std::multimap<unsigned int, WeaponMode*> weaponmodes_;
72	72
73		Timer~~<Weapon>~~ reloadTimer_;
	73	Timer reloadTimer_;
74	74	bool bReloading_;
75	75	unsigned int reloadingWeaponmode_;

code/trunk/src/orxonox/weaponsystem/WeaponMode.cc

r5781	r5929
57	57	this->bParallelReload_ = true;
58	58
59		this->reloadTimer_.setTimer(0.0f, false, ~~this, createExecutor(createFunctor(&WeaponMode::reloaded~~)));
	59	this->reloadTimer_.setTimer(0.0f, false, createExecutor(createFunctor(&WeaponMode::reloaded, this)));
60	60	this->reloadTimer_.stopTimer();
61	61

code/trunk/src/orxonox/weaponsystem/WeaponMode.h

-                      r5781
+                      r5929
 #include "util/Math.h"
 #include "core/BaseObject.h"
 #include "core/Identifier.h"
+#include "core/SubclassIdentifier.h"
 #include "tools/Timer.h"
 …
             std::string munitionname_;
             Timer<WeaponMode> reloadTimer_;
+            Timer reloadTimer_;
             bool bReloading_;
     };

code/trunk/src/orxonox/weaponsystem/WeaponPack.cc

r5781	r5929
54	54
55	55	while (!this->weapons_.empty())
56		~~delete (*this->weapons_.begin()~~);
	56	(*this->weapons_.begin())->destroy();
57	57
58	58	for (std::set<DefaultWeaponmodeLink*>::iterator it = this->links_.begin(); it != this->links_.end(); )
59		~~delete (*(it++)~~);
	59	(*(it++))->destroy();
60	60	}
61	61	}

code/trunk/src/orxonox/weaponsystem/WeaponSlot.cc

r5781	r5929
46	46	this->weapon_ = 0;
47	47
48		this->set~~Object~~Mode(0x0);
	48	this->setSyncMode(0x0);
49	49	}
50	50

code/trunk/src/orxonox/weaponsystem/WeaponSystem.cc

-                      r5781
+                      r5929
             while (!this->weaponSets_.empty())
                 delete (this->weaponSets_.begin()->second);
+                this->weaponSets_.begin()->second->destroy();
             while (!this->weaponPacks_.empty())
                 delete (*this->weaponPacks_.begin());
+                (*this->weaponPacks_.begin())->destroy();
             while (!this->weaponSlots_.empty())
                 delete (*this->weaponSlots_.begin());
+                (*this->weaponSlots_.begin())->destroy();
             while (!this->munitions_.empty())
                 { delete (this->munitions_.begin()->second); this->munitions_.erase(this->munitions_.begin()); }
+                { this->munitions_.begin()->second->destroy(); this->munitions_.erase(this->munitions_.begin()); }
+        }
+    }

code/trunk/src/orxonox/worldentities/BigExplosion.cc

r5781	r5929
90	90	this->setVelocity(velocity);
91	91
92		this->destroyTimer_.setTimer(rnd(2, 4), false, ~~this, createExecutor(createFunctor(&BigExplosion::stop~~)));
	92	this->destroyTimer_.setTimer(rnd(2, 4), false, createExecutor(createFunctor(&BigExplosion::stop, this)));
93	93	}
94	94	this->registerVariables();
…	…
226	226	{
227	227	this->debris1_->detachOgreObject(this->debrisFire1_->getParticleSystem());
228		~~delete this->debrisFire1_~~;
	228	this->debrisFire1_->destroy();
229	229	}
230	230	if (this->debrisSmoke1_)
231	231	{
232	232	this->debris1_->detachOgreObject(this->debrisSmoke1_->getParticleSystem());
233		~~delete this->debrisSmoke1_~~;
	233	this->debrisSmoke1_->destroy();
234	234	}
235	235
…	…
237	237	{
238	238	this->debris2_->detachOgreObject(this->debrisFire2_->getParticleSystem());
239		~~delete this->debrisFire2_~~;
	239	this->debrisFire2_->destroy();
240	240	}
241	241	if (this->debrisSmoke2_)
242	242	{
243	243	this->debris2_->detachOgreObject(this->debrisSmoke2_->getParticleSystem());
244		~~delete this->debrisSmoke2_~~;
	244	this->debrisSmoke2_->destroy();
245	245	}
246	246
…	…
248	248	{
249	249	this->debris3_->detachOgreObject(this->debrisFire3_->getParticleSystem());
250		~~delete this->debrisFire3_~~;
	250	this->debrisFire3_->destroy();
251	251	}
252	252	if (this->debrisSmoke3_)
253	253	{
254	254	this->debris3_->detachOgreObject(this->debrisSmoke3_->getParticleSystem());
255		~~delete this->debrisSmoke3_~~;
	255	this->debrisSmoke3_->destroy();
256	256	}
257	257
…	…
259	259	{
260	260	this->debris4_->detachOgreObject(this->debrisFire4_->getParticleSystem());
261		~~delete this->debrisFire4_~~;
	261	this->debrisFire4_->destroy();
262	262	}
263	263	if (this->debrisSmoke4_)
264	264	{
265	265	this->debris4_->detachOgreObject(this->debrisSmoke4_->getParticleSystem());
266		~~delete this->debrisSmoke4_~~;
	266	this->debrisSmoke4_->destroy();
267	267	}
268	268	}
…	…
329	329	{
330	330	this->bStop_ = true;
331		this->destroyTimer_.setTimer(1.0f, false, this, createExecutor(createFunctor(&BigExplosion::destroy)));
332		}
333		}
334
335		void BigExplosion::destroy()
336		{
337		delete this;
	331	this->destroyTimer_.setTimer(1.0f, false, createExecutor(createFunctor(&BigExplosion::destroy, this)));
	332	}
338	333	}
339	334

code/trunk/src/orxonox/worldentities/BigExplosion.h

-                      r5781
+                      r5929
             void checkStop();
             void stop();
-            void destroy();
             void init();
             void initZero();
 …
             ParticleInterface*    explosionFire_;
             LODParticle::Value      LOD_;
             Timer<BigExplosion> destroyTimer_;
+            LODParticle::Value    LOD_;
+            Timer                 destroyTimer_;
     };
+}

code/trunk/src/orxonox/worldentities/CameraPosition.cc

r5781	r5929
46	46	this->bRenderCamera_ = false;
47	47
48		this->set~~Object~~Mode(0x0);
	48	this->setSyncMode(0x0);
49	49	}
50	50

code/trunk/src/orxonox/worldentities/ControllableEntity.cc

r5781	r5929
96	96
97	97	if (this->xmlcontroller_)
98		~~delete this->xmlcontroller_~~;
	98	this->xmlcontroller_->destroy();
99	99
100	100	if (this->hud_)
101		~~delete this->hud_~~;
	101	this->hud_->destroy();
102	102
103	103	if (this->camera_)
104		~~delete this->camera_~~;
105
106		for (std::list<CameraPosition*>::const_iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
107		~~delete (*it~~);
	104	this->camera_->destroy();
	105
	106	for (std::list<SmartPtr<CameraPosition> >::const_iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
	107	(*it)->destroy();
108	108
109	109	if (this->getScene()->getSceneManager())
…	…
153	153	{
154	154	unsigned int i = 0;
155		for (std::list<CameraPosition*>::const_iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
	155	for (std::list<SmartPtr<CameraPosition> >::const_iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
156	156	{
157	157	if (i == index)
…	…
172	172	else if (this->cameraPositions_.size() > 0)
173	173	{
174		for (std::list<CameraPosition*>::const_iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
	174	for (std::list<SmartPtr<CameraPosition> >::const_iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
175	175	{
176	176	if ((*it) == this->camera_->getParent())
…	…
238	238	{
239	239	this->client_overwrite_ = this->server_overwrite_;
240		this->set~~Object~~Mode(ObjectDirection::Bidirectional);
	240	this->setSyncMode(ObjectDirection::Bidirectional);
241	241	}
242	242	}
…	…
254	254	this->bHasLocalController_ = false;
255	255	this->bHasHumanController_ = false;
256		this->set~~Object~~Mode(ObjectDirection::ToClient);
	256	this->setSyncMode(ObjectDirection::ToClient);
257	257
258	258	this->changedPlayer();
259	259
260	260	if (this->bDestroyWhenPlayerLeft_)
261		~~delete this~~;
	261	this->destroy();
262	262	}
263	263
…	…
275	275	void ControllableEntity::startLocalHumanControl()
276	276	{
277		if (!this->camera_)
	277	if (!this->camera_ && GameMode::showsGraphics())
278	278	{
279	279	this->camera_ = new Camera(this);
…	…
287	287	}
288	288
289		if (!this->hud_)
	289	if (!this->hud_ && GameMode::showsGraphics())
290	290	{
291	291	if (this->hudtemplate_ != "")
…	…
303	303	{
304	304	this->camera_->detachFromParent();
305		~~delete this->camera_~~;
	305	this->camera_->destroy();
306	306	this->camera_ = 0;
307	307	}
…	…
309	309	if (this->hud_)
310	310	{
311		~~delete this->hud_~~;
	311	this->hud_->destroy();
312	312	this->hud_ = 0;
313	313	}
…	…
333	333	if (parent)
334	334	{
335		for (std::list<CameraPosition*>::iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
	335	for (std::list<SmartPtr<CameraPosition> >::iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
336	336	if ((*it)->getIsAbsolute())
337	337	parent->attach((*it));

code/trunk/src/orxonox/worldentities/ControllableEntity.h

-                      r5781
+                      r5929
             void addCameraPosition(CameraPosition* position);
             CameraPosition* getCameraPosition(unsigned int index) const;
             inline const std::list<CameraPosition*>& getCameraPositions() const
+            inline const std::list<SmartPtr<CameraPosition> >& getCameraPositions() const
                 { return this->cameraPositions_; }
 …
             float mouseLookSpeed_;
             Ogre::SceneNode* cameraPositionRootNode_;
             std::list<CameraPosition*> cameraPositions_;
+            std::list<SmartPtr<CameraPosition> > cameraPositions_;
             std::string cameraPositionTemplate_;
             Controller* xmlcontroller_;

code/trunk/src/orxonox/worldentities/ExplosionChunk.cc

r5781	r5929
79	79	this->setVelocity(velocity);
80	80
81		this->destroyTimer_.setTimer(rnd(1, 2), false, ~~this, createExecutor(createFunctor(&ExplosionChunk::stop~~)));
	81	this->destroyTimer_.setTimer(rnd(1, 2), false, createExecutor(createFunctor(&ExplosionChunk::stop, this)));
82	82	}
83	83
…	…
92	92	{
93	93	this->detachOgreObject(this->fire_->getParticleSystem());
94		~~delete this->fire_~~;
	94	this->fire_->destroy();
95	95	}
96	96	if (this->smoke_)
97	97	{
98	98	this->detachOgreObject(this->smoke_->getParticleSystem());
99		~~delete this->smoke_~~;
	99	this->smoke_->destroy();
100	100	}
101	101	}
…	…
132	132	{
133	133	this->bStop_ = true;
134		this->destroyTimer_.setTimer(1.0f, false, ~~this, createExecutor(createFunctor(&ExplosionChunk::destroy~~)));
	134	this->destroyTimer_.setTimer(1.0f, false, createExecutor(createFunctor(&ExplosionChunk::destroy, this)));
135	135	}
136		}
137
138		~~void ExplosionChunk::destroy()~~
139		{
140		~~delete this;~~
141	136	}
142	137

code/trunk/src/orxonox/worldentities/ExplosionChunk.h

-                      r5781
+                      r5929
             void checkStop();
             void stop();
-            void destroy();
             bool                  bStop_;
             ParticleInterface*    fire_;
             ParticleInterface*    smoke_;
             LODParticle::Value      LOD_;
             Timer<ExplosionChunk> destroyTimer_;
+            LODParticle::Value    LOD_;
+            Timer                 destroyTimer_;
     };
+}

code/trunk/src/orxonox/worldentities/MovableEntity.cc

r5781	r5929
61	61	if (this->isInitialized())
62	62	if (this->continuousResynchroTimer_)
63		~~delete this->continuousResynchroTimer_~~;
	63	this->continuousResynchroTimer_->destroy();
64	64	}
65	65
…	…
98	98	void MovableEntity::clientConnected(unsigned int clientID)
99	99	{
100		this->resynchronizeTimer_.setTimer(rnd() * MAX_RESYNCHRONIZE_TIME, false, ~~this, createExecutor(createFunctor(&MovableEntity::resynchronize~~)));
	100	this->resynchronizeTimer_.setTimer(rnd() * MAX_RESYNCHRONIZE_TIME, false, createExecutor(createFunctor(&MovableEntity::resynchronize, this)));
101	101	}
102	102
…	…
110	110	{
111	111	// Resynchronise every few seconds because we only work with velocities (no positions)
112		continuousResynchroTimer_ = new Timer~~<MovableEntity>~~(CONTINUOUS_SYNCHRONIZATION_TIME + rnd(-1, 1),
113		true, ~~this, createExecutor(createFunctor(&MovableEntity::resynchronize~~)), false);
	112	continuousResynchroTimer_ = new Timer(CONTINUOUS_SYNCHRONIZATION_TIME + rnd(-1, 1),
	113	true, createExecutor(createFunctor(&MovableEntity::resynchronize, this)), false);
114	114	}
115	115

code/trunk/src/orxonox/worldentities/MovableEntity.h

-                      r5781
+                      r5929
             Quaternion overwrite_orientation_;
             Timer<MovableEntity> resynchronizeTimer_;
             Timer<MovableEntity>* continuousResynchroTimer_;
+            Timer resynchronizeTimer_;
+            Timer* continuousResynchroTimer_;
             Pawn* owner_;

code/trunk/src/orxonox/worldentities/SpawnPoint.cc

r5781	r5929
50	50	COUT(1) << "Error: SpawnPoint has no Gametype" << std::endl;
51	51
52		this->set~~Object~~Mode(0x0);
	52	this->setSyncMode(0x0);
53	53	}
54	54

code/trunk/src/orxonox/worldentities/SpawnPoint.h

r5781	r5929
33	33
34	34	#include <string>
35		#include "core/Identifier.h"
	35	#include "core/SubclassIdentifier.h"
36	36	#include "worldentities/StaticEntity.h"
37	37

code/trunk/src/orxonox/worldentities/WorldEntity.cc

r5781	r5929
119	119	{
120	120	if ((*it)->getDeleteWithParent())
121		~~delete (*(it++)~~);
	121	(*(it++))->destroy();
122	122	else
123	123	{
…	…
132	132	delete this->physicalBody_;
133	133	}
134		~~delete this->collisionShape_~~;
	134	this->collisionShape_->destroy();
135	135
136	136	this->node_->detachAllObjects();
…	…
175	175	void WorldEntity::registerVariables()
176	176	{
177		registerVariable(this->mainStateName_, VariableDirection::ToClient, new NetworkCallback<WorldEntity>(this, &WorldEntity::changedMainState));
	177	registerVariable(this->mainStateName_, VariableDirection::ToClient, new NetworkCallback<WorldEntity>(this, &WorldEntity::changedMainStateName));
178	178
179	179	registerVariable(this->bActive_, VariableDirection::ToClient, new NetworkCallback<WorldEntity>(this, &WorldEntity::changedActivity));

code/trunk/src/orxonox/worldentities/pawns/Destroyer.cc

r5781	r5929
40	40	RegisterObject(Destroyer);
41	41
42		UnderAttack* gametype = orxonox_cast<UnderAttack*>(this->getGametype());
	42	UnderAttack* gametype = orxonox_cast<UnderAttack*>(this->getGametype().get());
43	43	if (gametype)
44	44	{

code/trunk/src/orxonox/worldentities/pawns/Pawn.cc

-                      r5781
+                      r5929
 #include "network/NetworkFunction.h"
-#include "interfaces/PawnListener.h"
 #include "PawnManager.h"
 #include "infos/PlayerInfo.h"
 …
         if (this->isInitialized())
+        {
-            for (ObjectList<PawnListener>::iterator it = ObjectList<PawnListener>::begin(); it != ObjectList<PawnListener>::end(); ++it)
-                it->destroyedPawn(this);
             if (this->weaponSystem_)
                 delete this->weaponSystem_;
+                this->weaponSystem_->destroy();
+        }
+    }

code/trunk/src/orxonox/worldentities/pawns/SpaceShip.cc

r5781	r5929
75	75	{
76	76	if (this->isInitialized() && this->engine_)
77		~~delete this->engine_~~;
	77	this->engine_->destroy();
78	78	}
79	79
…	…
207	207	else
208	208	{
209		~~delete object~~;
	209	object->destroy();
210	210	}
211	211	}

code/trunk/src/orxonox/worldentities/pawns/Spectator.cc

r5781	r5929
145	145	ControllableEntity::setPlayer(player);
146	146
147		// this->set~~Object~~Mode(ObjectDirection::ToClient);
	147	// this->setSyncMode(ObjectDirection::ToClient);
148	148	}
149	149

code/trunk/src/orxonox/worldentities/pawns/TeamBaseMatchBase.cc

-                      r5781
+                      r5929
 #include "core/CoreIncludes.h"
 #include "interfaces/PawnListener.h"
+#include "controllers/ArtificialController.h"
 #include "interfaces/TeamColourable.h"
 #include "gametypes/TeamBaseMatch.h"
 …
         this->state_ = BaseState::Uncontrolled;
         TeamBaseMatch* gametype = orxonox_cast<TeamBaseMatch*>(this->getGametype());
+        TeamBaseMatch* gametype = orxonox_cast<TeamBaseMatch*>(this->getGametype().get());
         if (gametype)
+        {
 …
         this->fireEvent();
         TeamDeathmatch* gametype = orxonox_cast<TeamDeathmatch*>(this->getGametype());
+        TeamDeathmatch* gametype = orxonox_cast<TeamDeathmatch*>(this->getGametype().get());
         if (!gametype)
             return;
 …
         // Call this so bots stop shooting at the base after they converted it
         for (ObjectList<PawnListener>::iterator it = ObjectList<PawnListener>::begin(); it != ObjectList<PawnListener>::end(); ++it)
             it->destroyedPawn(this);
+        for (ObjectList<ArtificialController>::iterator it = ObjectList<ArtificialController>::begin(); it != ObjectList<ArtificialController>::end(); ++it)
+            it->abandonTarget(this);
+    }
+}

Context Navigation

Legend: