Changeset 8858 for code/trunk/src

code/trunk

Property svn:ignore

old	new
1	1	build
2	2	codeblocks
	3	vs
3	4	dependencies

Property svn:mergeinfo changed

/code/branches/output (added)

merged: 8739-8740,8765,8771-8772,8774-8780,8787-8789,8794-8799,8801,8803-8812,8814,8816-8817,8820,8822,8825-8837,8840,8844,8846,8848-8850,8853-8854

code/trunk/src/Orxonox.cc

-                      r8351
+                      r8858
 #endif
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "util/Exception.h"
 #include "orxonox/Main.h"
 …
 #endif
+{
+    using namespace orxonox;
+    orxout(user_status) << "Welcome to Orxonox (v" << ORXONOX_VERSION_MAJOR << '.' << ORXONOX_VERSION_MINOR << '.' << ORXONOX_VERSION_PATCH << ' ' << ORXONOX_VERSION_NAME << ')' << endl;
+    orxout(internal_status) << "Congratulations, you survived the static initialization. Entering main()" << endl;
+    if (argc > 0)
+        orxout(internal_info) << "argv[0]: " << argv[0] << endl;
     try
+    {
 …
         const int firstArgument = 1;
 #endif
         std::string strCmdLine;
         for (int i = firstArgument; i < argc; ++i)
 …
 #endif
+        return orxonox::main(strCmdLine);
+        int value = main(strCmdLine);
+        orxout(internal_status) << "Terminating main() normally with value " << value << endl;
+        return value;
+    }
     catch (...)
+    {
         COUT(0) << "Orxonox failed to initialise: " << orxonox::Exception::handleMessage() << std::endl;
         COUT(0) << "Terminating program." << std::endl;
+        orxout(user_error) << "Exception caught in main(): " << orxonox::Exception::handleMessage() << endl;
+        orxout(user_error) << "Terminating program." << endl;
         return 1;
+    }

code/trunk/src/OrxonoxConfig.h.in

-                      r8418
+                      r8858
 #  else
 #    define __FUNCTIONNAME__
+#  endif
+#endif
+// Declare a function deprecated
+#ifndef __DEPRECATED__
+#  if defined(ORXONOX_COMPILER_GCC)
+#    define __DEPRECATED__(function) function __attribute__ ((deprecated))
+#  elif defined(ORXONOX_COMPILER_MSVC)
+#    define __DEPRECATED__(function) __declspec(deprecated) function
+#  else
+#    define __DEPRECATED__(function) function
 #  endif
 #endif

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

r8706	r8858
109	109	void BaseObject::registerEventListener(BaseObject* object)
110	110	{
111		~~COUT(4) << "New EventListener: " << object->getIdentifier()->getName() << " &(" << object << ")." << std::~~endl;
	111	orxout(verbose, context::events) << "New EventListener: " << object->getIdentifier()->getName() << " &(" << object << ")." << endl;
112	112	this->eventListeners_.insert(object);
113	113	}
…	…
186	186	this->addTemplate(temp);
187	187	else
188		~~COUT(1) << "Error: \"" << name << "\" is not a valid Template name (in class: " << this->getIdentifier()->getName() << ", name: " << this->getName() << ")." << std::~~endl;
	188	orxout(internal_error) << "\"" << name << "\" is not a valid Template name (in class: " << this->getIdentifier()->getName() << ", name: " << this->getName() << ")." << endl;
189	189	}
190	190
…	…
312	312	if (it != this->eventStates_.end())
313	313	{
314		~~COUT(2) << "Warning: Overwriting EventState in class " << this->getIdentifier()->getName() << '.' << std::~~endl;
	314	orxout(internal_warning, context::events) << "Overwriting EventState in class " << this->getIdentifier()->getName() << '.' << endl;
315	315	delete (it->second);
316	316	}
…	…
379	379	this->registerEventStates();
380	380
381		COUT(4) << this->getIdentifier()->getName() << " (&" << this << ") processing event. originator: " << event.originator_->getIdentifier()->getName() << " (&" << event.originator_ << "), activate: " << event.activate_ << ", name: " << event.name_ << ", statename: " << event.statename_ << "." << std::endl;
	381	orxout(verbose, context::events) << this->getIdentifier()->getName() << " (&" << this << ") processing event. originator: " << event.originator_->getIdentifier()->getName() << " (&" << event.originator_ << "), activate: " << event.activate_ << ", name: " << event.name_ << ", statename: " << event.statename_ << "." << endl;
382	382
383	383	std::map<std::string, EventState*>::const_iterator it = this->eventStates_.find(event.statename_);
…	…
385	385	it->second->process(event, this);
386	386	else if (!event.statename_.empty())
387		~~COUT(2) << "Warning: \"" << event.statename_ << "\" is not a valid state in object \"" << this->getName() << "\" of class " << this->getIdentifier()->getName() << "." << std::~~endl;
388		else
389		~~COUT(2) << "Warning: Event with invalid source sent to object \"" << this->getName() << "\" of class " << this->getIdentifier()->getName() << "." << std::~~endl;
	387	orxout(internal_warning, context::events) << "\"" << event.statename_ << "\" is not a valid state in object \"" << this->getName() << "\" of class " << this->getIdentifier()->getName() << "." << endl;
	388	else
	389	orxout(internal_warning, context::events) << "Event with invalid source sent to object \"" << this->getName() << "\" of class " << this->getIdentifier()->getName() << "." << endl;
390	390	}
391	391
…	…
412	412	}
413	413	else
414		~~COUT(2) << "Warning: No MainState defined in object \"" << this->getName() << "\" (" << this->getIdentifier()->getName() << ")" << std::~~endl;
	414	orxout(internal_warning, context::events) << "No MainState defined in object \"" << this->getName() << "\" (" << this->getIdentifier()->getName() << ")" << endl;
415	415	}
416	416
…	…
432	432	this->mainStateFunctor_ = it->second->getFunctor();
433	433	else
434		~~COUT(2) << "Warning: Can't use \"" << this->mainStateName_ << "\" as MainState because it needs a second argument." << std::~~endl;
	434	orxout(internal_warning, context::events) << "Can't use \"" << this->mainStateName_ << "\" as MainState because it needs a second argument." << endl;
435	435	}
436	436	else
437		~~COUT(2) << "Warning: \"" << this->mainStateName_ << "\" is not a valid MainState." << std::~~endl;
	437	orxout(internal_warning, context::events) << "\"" << this->mainStateName_ << "\" is not a valid MainState." << endl;
438	438	}
439	439	}

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

r8729	r8858
86	86	input/KeyBinder.h
87	87	input/KeyBinderManager.h
	88	../util/output/OutputDefinitions.h
88	89	PCH_FILE
89	90	CorePrecompiledHeaders.h

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

-                      r7401
+                      r8858
 #include <string>
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "Identifier.h"
 …
             ClassFactory(const std::string& name, bool bLoadable = true)
+            {
                 COUT(4) << "*** ClassFactory: Create entry for " << name << " in Factory." << std::endl;
+                orxout(verbose, context::misc::factory) << "Create entry for " << name << " in Factory." << endl;
                 ClassIdentifier<T>::getIdentifier(name)->addFactory(this);
                 ClassIdentifier<T>::getIdentifier()->setLoadable(bLoadable);

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

-                      r8729
+                      r8858
 #include "util/Convert.h"
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "util/Exception.h"
 #include "util/StringUtils.h"
 …
         catch (const ArgumentException& ex)
+        {
             COUT(0) << "Could not parse command line: " << ex.what() << std::endl;
             COUT(0) << CommandLineParser::getUsageInformation() << std::endl;
+            orxout(user_error) << "Could not parse command line: " << ex.what() << endl;
+            orxout(user_error) << CommandLineParser::getUsageInformation() << endl;
             throw GeneralException("");
+        }
 …
+        }
         infoStr << std::endl;
         infoStr << "Usage: orxonox [options]" << std::endl;
         infoStr << "Available options:" << std::endl;
+        infoStr << endl;
+        infoStr << "Usage: orxonox [options]" << endl;
+        infoStr << "Available options:" << endl;
         for (std::map<std::string, CommandLineArgument*>::const_iterator it = inst.cmdLineArgs_.begin();
 …
             infoStr << std::string(maxNameSize - it->second->getName().size(), ' ');
             infoStr << ": " << it->second->getInformation();
             infoStr << std::endl;
+            infoStr << endl;
+        }
         return infoStr.str();

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

r8729	r8858
218	218	"Cannot add a command line argument with name '" + name + "' twice.");
219	219	OrxAssert(MultiType(defaultValue).getType() != MT_Type::Bool \|\| MultiType(defaultValue).getBool() != true,
220		"Boolean command line arguments with positive default values are not supported." << ~~std::~~endl
	220	"Boolean command line arguments with positive default values are not supported." << endl
221	221	<< "Please use SetCommandLineSwitch and adjust your argument: " << name);
222	222

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

r7401	r8858
123	123	for (std::list<ConfigFileEntry*>::const_iterator it = this->entries_.begin(); it != this->entries_.end(); ++it)
124	124	if ((*it)->getName() == name)
125		if ((*it)->getIndex() > size)
126		size = (*it)->getIndex();
127		if (size == 0)
128		return 0;
129		else
130		return (size + 1);
	125	if ((*it)->getIndex() >= size)
	126	size = (*it)->getIndex() + 1;
	127	return size;
131	128	}
132	129
…	…
274	271	{
275	272	boost::filesystem::copy_file(defaultFilepath, filepath);
276		~~COUT(3) << "Copied " << this->filename_ << " from the default config folder." << std::~~endl;
	273	orxout(internal_info, context::config) << "Copied " << this->filename_ << " from the default config folder." << endl;
277	274	}
278	275	catch (const boost::filesystem::filesystem_error& ex)
279		{ ~~COUT(1) << "Error in ConfigFile: " << ex.what() << std::~~endl; }
	276	{ orxout(user_error, context::config) << "Error in ConfigFile: " << ex.what() << endl; }
280	277	}
281	278	}
…	…
375	372	file.close();
376	373
377		~~COUT(3) << "Loaded config file \"" << this->filename_ << "\"." << std::~~endl;
	374	orxout(internal_info, context::config) << "Loaded config file \"" << this->filename_ << "\"." << endl;
378	375
379	376	// DO NOT save the file --> we can open supposedly read only config files
…	…
404	401	if (!file.is_open())
405	402	{
406		~~COUT(1) << "Error: Couldn't open config-file \"" << filename << "\"." << std::~~endl;
	403	orxout(user_error, context::config) << "Couldn't open config-file \"" << filename << "\"." << endl;
407	404	return;
408	405	}
…	…
410	407	for (std::list<ConfigFileSection*>::const_iterator it = this->sections_.begin(); it != this->sections_.end(); ++it)
411	408	{
412		file << (*it)->getFileEntry() << ~~std::~~endl;
	409	file << (*it)->getFileEntry() << endl;
413	410
414	411	for (std::list<ConfigFileEntry>::const_iterator it_entries = (it)->getEntriesBegin(); it_entries != (*it)->getEntriesEnd(); ++it_entries)
415		file << (*it_entries)->getFileEntry() << ~~std::~~endl;
416
417		file << ~~std::~~endl;
	412	file << (*it_entries)->getFileEntry() << endl;
	413
	414	file << endl;
418	415	}
419	416
420	417	file.close();
421	418
422		~~COUT(4) << "Saved config file \"" << filename << "\"." << std::~~endl;
	419	orxout(verbose, context::config) << "Saved config file \"" << filename << "\"." << endl;
423	420	}
424	421
…	…
669	666	{
670	667	if (!this->configImpl(section, entry, value, &ConfigValueContainer::set))
671		~~COUT(1) << "Error: Config value \"" << entry << "\" in section \"" << section << "\" doesn't exist." << std::~~endl;
	668	orxout(user_error, context::config) << "Config value \"" << entry << "\" in section \"" << section << "\" doesn't exist." << endl;
672	669	}
673	670
…	…
682	679	{
683	680	if (!this->configImpl(section, entry, value, &ConfigValueContainer::tset))
684		~~COUT(1) << "Error: Config value \"" << entry << "\" in section \"" << section << "\" doesn't exist." << std::~~endl;
	681	orxout(user_error, context::config) << "Config value \"" << entry << "\" in section \"" << section << "\" doesn't exist." << endl;
685	682	}
686	683

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

r8351	r8858
143	143	else
144	144	{
145		~~COUT(1) << "Error: Config-value '" << this->varname_ << "' in " << this->sectionname_ << " is not a vector." << std::~~endl;
	145	orxout(user_error, context::config) << "Config-value '" << this->varname_ << "' in " << this->sectionname_ << " is not a vector." << endl;
146	146	}
147	147	return false;
…	…
182	182	if (index > MAX_VECTOR_INDEX)
183	183	{
184		~~COUT(1) << "Error: Index " << index << " is too large." << std::~~endl;
	184	orxout(user_error, context::config) << "Index " << index << " is too large." << endl;
185	185	return false;
186	186	}
…	…
203	203	else
204	204	{
205		~~COUT(1) << "Error: Config-value '" << this->varname_ << "' in " << this->sectionname_ << " is not a vector." << std::~~endl;
	205	orxout(user_error, context::config) << "Config-value '" << this->varname_ << "' in " << this->sectionname_ << " is not a vector." << endl;
206	206	return false;
207	207	}
…	…
218	218	return this->set(this->valueVector_.size(), input);
219	219
220		~~COUT(1) << "Error: Config-value '" << this->varname_ << "' in " << this->sectionname_ << " is not a vector." << std::~~endl;
	220	orxout(user_error, context::config) << "Config-value '" << this->varname_ << "' in " << this->sectionname_ << " is not a vector." << endl;
221	221	return false;
222	222	}
…	…
241	241	return true;
242	242	}
243		~~COUT(1) << "Error: Invalid vector-index." << std::~~endl;
244		}
245
246		~~COUT(1) << "Error: Config-value '" << this->varname_ << "' in " << this->sectionname_ << " is not a vector." << std::~~endl;
	243	orxout(user_error, context::config) << "Invalid vector-index." << endl;
	244	}
	245
	246	orxout(user_error, context::config) << "Config-value '" << this->varname_ << "' in " << this->sectionname_ << " is not a vector." << endl;
247	247	return false;
248	248	}
…	…
312	312	if (!success)
313	313	{
314		~~COUT(1) << "Error: Config-value '" << this->varname_ << "' in " << this->sectionname_ << " is a vector." << std::~~endl;
	314	orxout(user_error, context::config) << "Config-value '" << this->varname_ << "' in " << this->sectionname_ << " is a vector." << endl;
315	315	}
316	316	else
317	317	{
318		~~COUT(1) << "Error: Invalid vector-index." << std::~~endl;
	318	orxout(user_error, context::config) << "Invalid vector-index." << endl;
319	319	}
320	320	return false;

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

-                      r8729
+                      r8858
     @code
     MyObject orxonoxobject;
     std::cout << "Name:    " << orxonoxobject.getName() << std::endl;
     std::cout << "Version: " << orxonoxobject.getVersion() << std::endl;
+    orxout() << "Name:    " << orxonoxobject.getName() << endl;
+    orxout() << "Version: " << orxonoxobject.getVersion() << endl;
     @endcode
 …
         else
+        {
             COUT(2) << "Warning: Couldn't reset config-value '" << entryName << "' in class '"
                     << ClassIdentifier<T>::getIdentifier()->getName() << "', corresponding container doesn't exist." << std::endl;
+            orxout(user_warning, context::config) << "Couldn't reset config-value '" << entryName << "' in class '"
+                                                  << ClassIdentifier<T>::getIdentifier()->getName() << "', corresponding container doesn't exist." << endl;
+        }
+    }
 …
     else \
     { \
         COUT(2) << "Warning: Couln't modify config-value '" << entryName << "' in class '" \
                 << ClassByObjectType(object)->getName() << "', corresponding container doesn't exist." << std::endl; \
+        orxout(user_warning, context::config) << "Couldn't modify config-value '" << entryName << "' in class '" \
+                                              << ClassByObjectType(object)->getName() << "', corresponding container doesn't exist." << endl; \
+    }

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

-                      r8729
+                      r8858
 #include "util/Clock.h"
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "util/Exception.h"
+#include "util/output/LogWriter.h"
 #include "util/Scope.h"
 #include "util/ScopedSingletonManager.h"
 …
         , destructionHelper_(this)
+    {
+        orxout(internal_status) << "initializing Core object..." << endl;
         // Set the hard coded fixed paths
         this->pathConfig_ = new PathConfig();
 …
         // Load modules
+        orxout(internal_info) << "Loading modules:" << endl;
         const std::vector<std::string>& modulePaths = this->pathConfig_->getModulePaths();
         for (std::vector<std::string>::const_iterator it = modulePaths.begin(); it != modulePaths.end(); ++it)
 …
             catch (...)
+            {
                 COUT(1) << "Couldn't load module \"" << *it << "\": " << Exception::handleMessage() << std::endl;
+                orxout(user_error) << "Couldn't load module \"" << *it << "\": " << Exception::handleMessage() << endl;
+            }
+        }
 …
         // Set configurable paths like log, config and media
         this->pathConfig_->setConfigurablePaths();
+        orxout(internal_info) << "Root path:       " << PathConfig::getRootPathString() << endl;
+        orxout(internal_info) << "Executable path: " << PathConfig::getExecutablePathString() << endl;
+        orxout(internal_info) << "Data path:       " << PathConfig::getDataPathString() << endl;
+        orxout(internal_info) << "Ext. data path:  " << PathConfig::getExternalDataPathString() << endl;
+        orxout(internal_info) << "Config path:     " << PathConfig::getConfigPathString() << endl;
+        orxout(internal_info) << "Log path:        " << PathConfig::getLogPathString() << endl;
+        orxout(internal_info) << "Modules path:    " << PathConfig::getModulePathString() << endl;
         // create a signal handler (only active for Linux)
 …
         this->signalHandler_ = new SignalHandler();
         this->signalHandler_->doCatch(PathConfig::getExecutablePathString(), PathConfig::getLogPathString() + "orxonox_crash.log");
-        // Set the correct log path. Before this call, /tmp (Unix) or %TEMP% (Windows) was used
-        OutputHandler::getInstance().setLogPath(PathConfig::getLogPathString());
 #ifdef ORXONOX_PLATFORM_WINDOWS
 …
         // Manage ini files and set the default settings file (usually orxonox.ini)
+        orxout(internal_info) << "Loading config:" << endl;
         this->configFileManager_ = new ConfigFileManager();
         this->configFileManager_->setFilename(ConfigFileType::Settings,
 …
         // Required as well for the config values
+        orxout(internal_info) << "Loading language:" << endl;
         this->languageInstance_ = new Language();
 …
         // possibility to configure everything below here
         RegisterRootObject(Core);
+        orxout(internal_info) << "configuring Core" << endl;
         this->setConfigValues();
+        // Rewrite the log file with the correct log levels
+        OutputHandler::getInstance().rewriteLogFile();
+        // Set the correct log path and rewrite the log file with the correct log levels
+        LogWriter::getInstance().setLogPath(PathConfig::getLogPathString());
 #if !defined(ORXONOX_PLATFORM_APPLE) && !defined(ORXONOX_USE_WINMAIN)
 …
+        }
         if (this->bStartIOConsole_)
+        {
+            orxout(internal_info) << "creating IO console" << endl;
             this->ioConsole_ = new IOConsole();
+        }
 #endif
         // creates the class hierarchy for all classes with factories
+        orxout(internal_info) << "creating class hierarchy" << endl;
         Identifier::createClassHierarchy();
         // Load OGRE excluding the renderer and the render window
+        orxout(internal_info) << "creating GraphicsManager:" << endl;
         this->graphicsManager_ = new GraphicsManager(false);
 …
         // Create singletons that always exist (in other libraries)
+        orxout(internal_info) << "creating root scope:" << endl;
         this->rootScope_ = new Scope<ScopeID::Root>();
 …
+            }
             else
+                COUT(0) << "Error: Could not open file for documentation writing" << endl;
+        }
+                orxout(internal_error) << "Could not open file for documentation writing" << endl;
+        }
+        orxout(internal_status) << "finished initializing Core object" << endl;
+    }
     void Core::destroy()
+    {
+        orxout(internal_status) << "destroying Core object..." << endl;
         // Remove us from the object lists again to avoid problems when destroying them
         this->unregisterObject();
 …
         safeObjectDelete(&dynLibManager_);
         safeObjectDelete(&pathConfig_);
+    }
+    namespace DefaultLevelLogFile
+    {
+        const OutputLevel::Value Dev  = OutputLevel::Debug;
+        const OutputLevel::Value User = OutputLevel::Info;
+        orxout(internal_status) << "finished destroying Core object" << endl;
+    }
 …
     void Core::setConfigValues()
+    {
+        // Choose the default level according to the path Orxonox was started (build directory or not)
+        OutputLevel::Value defaultLogLevel = (PathConfig::buildDirectoryRun() ? DefaultLevelLogFile::Dev : DefaultLevelLogFile::User);
+        SetConfigValueExternal(debugLevelLogFile_, "OutputHandler", "debugLevelLogFile", defaultLogLevel)
+            .description("The maximum level of debug output written to the log file");
+        OutputHandler::getInstance().setSoftDebugLevel("LogFile", debugLevelLogFile_);
+        SetConfigValueExternal(LogWriter::getInstance().configurableMaxLevel_,
+                               LogWriter::getInstance().getConfigurableSectionName(),
+                               LogWriter::getInstance().getConfigurableMaxLevelName(),
+                               LogWriter::getInstance().configurableMaxLevel_)
+            .description("The maximum level of output shown in the log file")
+            .callback(static_cast<BaseWriter*>(&LogWriter::getInstance()), &BaseWriter::changedConfigurableLevel);
+        SetConfigValueExternal(LogWriter::getInstance().configurableAdditionalContextsMaxLevel_,
+                               LogWriter::getInstance().getConfigurableSectionName(),
+                               LogWriter::getInstance().getConfigurableAdditionalContextsMaxLevelName(),
+                               LogWriter::getInstance().configurableAdditionalContextsMaxLevel_)
+            .description("The maximum level of output shown in the log file for additional contexts")
+            .callback(static_cast<BaseWriter*>(&LogWriter::getInstance()), &BaseWriter::changedConfigurableAdditionalContextsLevel);
+        SetConfigValueExternal(LogWriter::getInstance().configurableAdditionalContexts_,
+                               LogWriter::getInstance().getConfigurableSectionName(),
+                               LogWriter::getInstance().getConfigurableAdditionalContextsName(),
+                               LogWriter::getInstance().configurableAdditionalContexts_)
+            .description("Additional output contexts shown in the log file")
+            .callback(static_cast<BaseWriter*>(&LogWriter::getInstance()), &BaseWriter::changedConfigurableAdditionalContexts);
         SetConfigValue(bDevMode_, PathConfig::buildDirectoryRun())
 …
     void Core::devModeChanged()
+    {
-        bool isNormal = (bDevMode_ == PathConfig::buildDirectoryRun());
-        if (isNormal)
+        {
-            ModifyConfigValueExternal(debugLevelLogFile_, "debugLevelLogFile", update);
+        }
-        else
+        {
-            OutputLevel::Value level = (bDevMode_ ? DefaultLevelLogFile::Dev : DefaultLevelLogFile::User);
-            ModifyConfigValueExternal(debugLevelLogFile_, "debugLevelLogFile", tset, level);
+        }
         // Inform listeners
         ObjectList<DevModeListener>::iterator it = ObjectList<DevModeListener>::begin();
 …
     void Core::loadGraphics()
+    {
+        orxout(internal_info) << "loading graphics in Core" << endl;
         // Any exception should trigger this, even in upgradeToGraphics (see its remarks)
         Loki::ScopeGuard unloader = Loki::MakeObjGuard(*this, &Core::unloadGraphics);
 …
+        {
             // Exit the application if the Ogre config dialog was canceled
             COUT(1) << Exception::handleMessage() << std::endl;
+            orxout(user_error) << Exception::handleMessage() << endl;
             exit(EXIT_FAILURE);
+        }
 …
             // and reloaded between throw and catch (access violation in MSVC).
             // That's why we abort completely and only display the exception.
             COUT(1) << "An exception occurred during upgrade to graphics. "
                     << "That is unrecoverable. The message was:" << endl
                     << Exception::handleMessage() << endl;
+            orxout(user_error) << "An exception occurred during upgrade to graphics. "
+                               << "That is unrecoverable. The message was:" << endl
+                               << Exception::handleMessage() << endl;
             abort();
+        }
 …
         // Create singletons associated with graphics (in other libraries)
+        orxout(internal_info) << "creating graphics scope:" << endl;
         graphicsScope_ = new Scope<ScopeID::Graphics>();
         unloader.Dismiss();
+        orxout(internal_info) << "finished loading graphics in Core" << endl;
+    }
     void Core::unloadGraphics()
+    {
+        orxout(internal_info) << "unloading graphics in Core" << endl;
         safeObjectDelete(&graphicsScope_);
         safeObjectDelete(&guiManager_);
 …
         catch (...)
+        {
             COUT(0) << "An exception occurred during 'unloadGraphics':" << Exception::handleMessage() << std::endl
                     << "Another exception might be being handled which may lead to undefined behaviour!" << std::endl
                     << "Terminating the program." << std::endl;
+            orxout(user_error) << "An exception occurred during 'unloadGraphics':" << Exception::handleMessage() << endl
+                               << "Another exception might be being handled which may lead to undefined behaviour!" << endl
+                               << "Terminating the program." << endl;
             abort();
+        }

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

r8729	r8858
136	136
137	137	bool bGraphicsLoaded_;
138		~~int debugLevelLogFile_; //!< The debug level for the log file (belongs to OutputHandler)~~
139	138	std::string language_; //!< The language
140	139	bool bInitRandomNumberGenerator_; //!< If true, srand(time(0)) is called

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

-                      r8729
+                      r8858
 /**
     @file
     @ingroup Object Factory
+    @ingroup Object Factory Class Identifier
     @brief Defines several very important macros used to register objects, create factories, and to work with identifiers.
 …
 #include "CorePrereqs.h"
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "Identifier.h"
 #include "ClassFactory.h"

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

r7266	r8858
51	51	#include <set> // 50
52	52
53		#include "util/~~Debug~~.h" // 48
	53	#include "util/Output.h" // 48
54	54
55	55	#include <deque> // 43

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

-                      r8351
+                      r8858
+    {
         // Log library load
         COUT(2) << "Loading module " << mName << std::endl;
+        orxout(internal_info) << "Loading module " << mName << endl;
         std::string name = mName;
 …
+    {
         // Log library unload
         COUT(4) << "Unloading module " << mName << std::endl;
+        orxout(internal_info) << "Unloading module " << mName << endl;
         if (DYNLIB_UNLOAD( m_hInst ))

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

-                      r7401
+                      r8858
         if (this->bProcessingEvent_)
+        {
             COUT(2) << "Warning: Detected Event loop in section \"" << event.statename_ << "\" of object \"" << object->getName() << "\" and fired by \"" << event.originator_->getName() << '"' << std::endl;
+            orxout(internal_warning, context::events) << "Detected Event loop in section \"" << event.statename_ << "\" of object \"" << object->getName() << "\" and fired by \"" << event.originator_->getName() << '"' << endl;
             return;
+        }
 …
         this->bProcessingEvent_ = true;
         COUT(4) << "Processing event (EventState) : originator: " << event.originator_->getIdentifier()->getName() << " (&" << event.originator_ << "), activate: " << event.activate_ << ", name: " << event.name_ << ", statename: " << event.statename_ << ", object: " << object->getIdentifier()->getName() << " (&" << object << ")" << "." << std::endl;
+        orxout(verbose, context::events) << "Processing event (EventState) : originator: " << event.originator_->getIdentifier()->getName() << " (&" << event.originator_ << "), activate: " << event.activate_ << ", name: " << event.name_ << ", statename: " << event.statename_ << ", object: " << object->getIdentifier()->getName() << " (&" << object << ")" << "." << endl;
         // check if the originator is an instance of the requested class

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

-                      r8729
+                      r8858
 #include "util/Clock.h"
 #include "util/Convert.h"
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "util/Exception.h"
 #include "util/Math.h"
 #include "util/OrxAssert.h"
+#include "util/output/BaseWriter.h"
 #include "ConfigValueIncludes.h"
 #include "Core.h"
 …
         void logEvent(const CEGUI::String& message, CEGUI::LoggingLevel level = CEGUI::Standard)
+        {
             int orxonoxLevel = CEGUI::Standard;
+            OutputLevel orxonoxLevel = level::debug_output;
             switch (level)
+            {
                 case CEGUI::Errors:      orxonoxLevel = 1; break;
                 case CEGUI::Warnings:    orxonoxLevel = 2; break;
                 case CEGUI::Standard:    orxonoxLevel = 4; break;
                 case CEGUI::Informative: orxonoxLevel = 5; break;
                 case CEGUI::Insane:      orxonoxLevel = 6; break;
+                case CEGUI::Errors:      orxonoxLevel = level::internal_error; break;
+                case CEGUI::Warnings:    orxonoxLevel = level::internal_warning; break;
+                case CEGUI::Standard:    orxonoxLevel = level::verbose; break;
+                case CEGUI::Informative: orxonoxLevel = level::verbose_more; break;
+                case CEGUI::Insane:      orxonoxLevel = level::verbose_ultra; break;
                 default: OrxAssert(false, "CEGUI log level out of range, inspect immediately!");
+            }
+            OutputHandler::getOutStream(orxonoxLevel)
                 << "CEGUI: " << message << std::endl;
+            orxout(orxonoxLevel, context::cegui) << message << endl;
             CEGUI::DefaultLogger::logEvent(message, level);
 …
+    {
         RegisterRootObject(GUIManager);
+        orxout(internal_status) << "initializing GUIManager..." << endl;
         this->setConfigValues();
         using namespace CEGUI;
         COUT(3) << "Initialising CEGUI." << std::endl;
+        orxout(internal_info) << "Initialising CEGUI." << endl;
         this->oldCEGUI_ = false;
         // Note: No SceneManager specified yet
 #ifdef ORXONOX_OLD_CEGUI
 …
         std::auto_ptr<CEGUILogger> ceguiLogger(new CEGUILogger());
         ceguiLogger->setLogFilename(PathConfig::getLogPathString() + "cegui.log");
+        // Set the log level according to ours (translate by subtracting 1)
+        ceguiLogger->setLoggingLevel(
+            static_cast<LoggingLevel>(OutputHandler::getInstance().getSoftDebugLevel("logFile") - 1));
+        ceguiLogger->setLoggingLevel(static_cast<CEGUI::LoggingLevel>(this->outputLevelCeguiLog_));
         this->ceguiLogger_ = ceguiLogger.release();
 …
         // Set up the sheet manager in the Lua framework
         this->luaState_->doFile("SheetManager.lua");
+        orxout(internal_status) << "finished initializing GUIManager" << endl;
+    }
     void GUIManager::destroy()
+    {
+        orxout(internal_status) << "destroying GUIManager..." << endl;
         using namespace CEGUI;
 …
 #endif
         safeObjectDelete(&luaState_);
+        orxout(internal_status) << "finished destroying GUIManager" << endl;
+    }
     void GUIManager::setConfigValues(void)
+    {
         SetConfigValue(guiScheme_, GUIManager::defaultScheme_) .description("Changes the current GUI scheme.") .callback(this, &GUIManager::changedGUIScheme);
+        SetConfigValue(guiScheme_, GUIManager::defaultScheme_).description("Changes the current GUI scheme.").callback(this, &GUIManager::changedGUIScheme);
         SetConfigValue(numScrollLines_, 1).description("How many lines to scroll in a list if the scroll wheel is used");
+        SetConfigValueExternal(outputLevelCeguiLog_, BaseWriter::getConfigurableSectionName(), "outputLevelCeguiLog", CEGUI::Standard).description("The log level of the CEGUI log file").callback(this, &GUIManager::changedCeguiOutputLevel);
+    }
     void GUIManager::changedGUIScheme(void)
+    {
+    }
+    void GUIManager::changedCeguiOutputLevel()
+    {
+        if (this->ceguiLogger_)
+            this->ceguiLogger_->setLoggingLevel(static_cast<CEGUI::LoggingLevel>(this->outputLevelCeguiLog_));
+    }
 …
+        {
             // Display the error and proceed. See @remarks why this can be dangerous.
             COUT(1) << ex.getMessage() << std::endl;
+            orxout(internal_error) << ex.getMessage() << endl;
             return true;
+        }

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

-                      r8729
+                      r8858
         bool protectedCall(FunctionType function);
+        void changedCeguiOutputLevel();
         // keyHandler functions
         void buttonPressed (const KeyEvent& evt);
 …
 #ifdef ORXONOX_OLD_CEGUI
         CEGUI::OgreCEGUIRenderer*            guiRenderer_;      //!< CEGUI's interface to the Ogre Engine
         CEGUI::ResourceProvider*             resourceProvider_; //!< CEGUI's resource provider
+        CEGUI::OgreCEGUIRenderer*            guiRenderer_;          //!< CEGUI's interface to the Ogre Engine
+        CEGUI::ResourceProvider*             resourceProvider_;     //!< CEGUI's resource provider
 #else
         CEGUI::OgreRenderer*                 guiRenderer_;      //!< CEGUI's interface to the Ogre Engine
         CEGUI::OgreResourceProvider*         resourceProvider_; //!< CEGUI's resource provider
         Ogre::RenderQueueListener*           rqListener_;       //!< RQ listener so we can draw UNDER Ogre overlays
+        CEGUI::OgreRenderer*                 guiRenderer_;          //!< CEGUI's interface to the Ogre Engine
+        CEGUI::OgreResourceProvider*         resourceProvider_;     //!< CEGUI's resource provider
+        Ogre::RenderQueueListener*           rqListener_;           //!< RQ listener so we can draw UNDER Ogre overlays
         CEGUI::OgreImageCodec*               imageCodec_;
 #endif
+        LuaState*                            luaState_;         //!< LuaState, access point to the Lua engine
+        CEGUI::LuaScriptModule*              scriptModule_;     //!< CEGUI's script module to use Lua
+        CEGUI::System*                       guiSystem_;        //!< CEGUI's main system
+        shared_ptr<ResourceInfo>             rootFileInfo_;     //!< Resource information about the root script
+        CEGUI::Logger*                       ceguiLogger_;      //!< CEGUI's logger to be able to log CEGUI errors in our log
+        CEGUI::Window*                       rootWindow_;       //!< Root node for all windows
+        CEGUI::Window*                       hudRootWindow_;    //!< Root node for the HUD sheets
+        CEGUI::Window*                       menuRootWindow_;   //!< Root node for the menu sheets (used by Lua)
+        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
+        LuaState*                            luaState_;             //!< LuaState, access point to the Lua engine
+        CEGUI::LuaScriptModule*              scriptModule_;         //!< CEGUI's script module to use Lua
+        CEGUI::System*                       guiSystem_;            //!< CEGUI's main system
+        shared_ptr<ResourceInfo>             rootFileInfo_;         //!< Resource information about the root script
+        CEGUI::Logger*                       ceguiLogger_;          //!< CEGUI's logger to be able to log CEGUI errors in our log
+        int                                  outputLevelCeguiLog_;  //!< CEGUI's log level
+        CEGUI::Window*                       rootWindow_;           //!< Root node for all windows
+        CEGUI::Window*                       hudRootWindow_;        //!< Root node for the HUD sheets
+        CEGUI::Window*                       menuRootWindow_;       //!< Root node for the menu sheets (used by Lua)
+        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
         /// Helper object that executes the surrogate destructor destroy()
         DestructionHelper<GUIManager>        destructionHelper_;
         static GUIManager*                   singletonPtr_s;    //!< Singleton reference to GUIManager
+        static GUIManager*                   singletonPtr_s;        //!< Singleton reference to GUIManager
         // The used CEGUI scheme.
 …
         std::string guiScheme_;
         bool oldCEGUI_;
         int numScrollLines_; ///< How many lines to scroll in a list if the scroll wheel is used

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

-                      r8729
+                      r8858
 #include "util/Clock.h"
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "util/Exception.h"
 #include "util/Sleep.h"
 …
     SetConsoleCommand("exit", &stop_game);
     static void printFPS()
         { COUT(0) << Game::getInstance().getAvgFPS() << std::endl; }
+        { orxout(message) << Game::getInstance().getAvgFPS() << endl; }
     SetConsoleCommand("Stats", "printFPS", &printFPS);
     static void printTickTime()
         { COUT(0) << Game::getInstance().getAvgTickTime() << std::endl; }
+        { orxout(message) << Game::getInstance().getAvgTickTime() << endl; }
     SetConsoleCommand("Stats", "printTickTime", &printTickTime);
 …
         , destructionHelper_(this)
+    {
+        orxout(internal_status) << "initializing Game object..." << endl;
 #ifdef ORXONOX_PLATFORM_WINDOWS
         minimumSleepTime_ = 1000/*us*/;
 …
         // Create the Core
+        orxout(internal_info) << "creating Core object:" << endl;
         this->core_ = new Core(cmdLine);
 …
         this->loadedTopStateNode_ = this->rootStateNode_;
         this->loadedStates_.push_back(this->getState(rootStateNode_->name_));
+        orxout(internal_status) << "finished initializing Game object" << endl;
+    }
     void Game::destroy()
+    {
+        orxout(internal_status) << "destroying Game object..." << endl;
         // Remove us from the object lists again to avoid problems when destroying them
         this->unregisterObject();
 …
         safeObjectDelete(&core_);
         safeObjectDelete(&gameClock_);
+        orxout(internal_status) << "finished destroying Game object..." << endl;
+    }
 …
+    {
         if (this->requestedStateNodes_.empty())
+            COUT(0) << "Warning: Starting game without requesting GameState. This automatically terminates the program." << std::endl;
+            orxout(user_error) << "Starting game without requesting GameState. This automatically terminates the program." << endl;
+        // Update the GameState stack if required. We do this already here to have a properly initialized game before entering the main loop
+        this->updateGameStateStack();
+        orxout(user_status) << "Game loaded" << endl;
+        orxout(internal_status) << "--------------------------------------------------" << endl;
+        orxout(internal_status) << "starting main loop..." << endl;
         // START GAME
 …
             catch (...)
+            {
                 COUT(0) << "An exception occurred in the Core preUpdate: " << Exception::handleMessage() << std::endl;
                 COUT(0) << "This should really never happen! Closing the program." << std::endl;
+                orxout(user_error) << "An exception occurred in the Core preUpdate: " << Exception::handleMessage() << endl;
+                orxout(user_error) << "This should really never happen! Closing the program." << endl;
                 this->stop();
                 break;
 …
             catch (...)
+            {
                 COUT(0) << "An exception occurred in the Core postUpdate: " << Exception::handleMessage() << std::endl;
                 COUT(0) << "This should really never happen! Closing the program." << std::endl;
+                orxout(user_error) << "An exception occurred in the Core postUpdate: " << Exception::handleMessage() << endl;
+                orxout(user_error) << "This should really never happen! Closing the program." << endl;
                 this->stop();
                 break;
 …
                 this->updateFPSLimiter();
+        }
+        orxout(internal_status) << "finished main loop" << endl;
+        orxout(internal_status) << "--------------------------------------------------" << endl;
         // UNLOAD all remaining states
 …
                 catch (...)
+                {
                     COUT(1) << "Error: Loading GameState '" << requestedStateNode->name_ << "' failed: " << Exception::handleMessage() << std::endl;
+                    orxout(user_error) << "Loading GameState '" << requestedStateNode->name_ << "' failed: " << Exception::handleMessage() << endl;
                     // All scheduled operations have now been rendered inert --> flush them and issue a warning
                     if (this->requestedStateNodes_.size() > 1)
                         COUT(4) << "All " << this->requestedStateNodes_.size() - 1 << " scheduled transitions have been ignored." << std::endl;
+                        orxout(internal_info) << "All " << this->requestedStateNodes_.size() - 1 << " scheduled transitions have been ignored." << endl;
                     this->requestedStateNodes_.clear();
                     break;
 …
             catch (...)
+            {
                 COUT(1) << "An exception occurred while updating '" << (*it)->getName() << "': " << Exception::handleMessage() << std::endl;
                 COUT(1) << "This should really never happen!" << std::endl;
                 COUT(1) << "Unloading all GameStates depending on the one that crashed." << std::endl;
+                orxout(user_error) << "An exception occurred while updating '" << (*it)->getName() << "': " << Exception::handleMessage() << endl;
+                orxout(user_error) << "This should really never happen!" << endl;
+                orxout(user_error) << "Unloading all GameStates depending on the one that crashed." << endl;
                 shared_ptr<GameStateTreeNode> current = this->loadedTopStateNode_;
                 while (current->name_ != (*it)->getName() && current)
 …
     void Game::stop()
+    {
+        orxout(user_status) << "Exit" << endl;
         this->bAbort_ = true;
+    }
 …
         if (!this->checkState(name))
+        {
             COUT(2) << "Warning: GameState named '" << name << "' doesn't exist!" << std::endl;
+            orxout(user_warning) << "GameState named '" << name << "' doesn't exist!" << endl;
             return;
+        }
 …
         if (this->bChangingState_)
+        {
             COUT(2) << "Warning: Requesting GameStates while loading/unloading a GameState is illegal! Ignoring." << std::endl;
+            orxout(user_warning) << "Requesting GameStates while loading/unloading a GameState is illegal! Ignoring." << endl;
             return;
+        }
 …
         if (name == lastRequestedNode->name_)
+        {
             COUT(2) << "Warning: Requesting the currently active state! Ignoring." << std::endl;
+            orxout(user_warning) << "Requesting the currently active state! Ignoring." << endl;
             return;
+        }
 …
         if (requestedNodes.empty())
             COUT(1) << "Error: Requested GameState transition is not allowed. Ignoring." << std::endl;
+            orxout(user_error) << "Requested GameState transition is not allowed. Ignoring." << endl;
         else
             this->requestedStateNodes_.insert(requestedStateNodes_.end(), requestedNodes.begin(), requestedNodes.end());
 …
             this->requestState(lastRequestedNode->parent_.lock()->name_);
         else
             COUT(2) << "Warning: Can't pop the internal dummy root GameState" << std::endl;
+            orxout(internal_warning) << "Can't pop the internal dummy root GameState" << endl;
+    }
 …
             std::map<std::string, GameStateInfo>::const_iterator it = gameStateDeclarations_s.find(name);
             if (it != gameStateDeclarations_s.end())
                 COUT(1) << "Error: GameState '" << name << "' has not yet been loaded." << std::endl;
+                orxout(internal_error) << "GameState '" << name << "' has not yet been loaded." << endl;
             else
                 COUT(1) << "Error: Could not find GameState '" << name << "'." << std::endl;
+                orxout(internal_error) << "Could not find GameState '" << name << "'." << endl;
             return shared_ptr<GameState>();
+        }
 …
         if (!GameMode::showsGraphics())
+        {
+            orxout(user_status) << "Loading graphics" << endl;
+            orxout(internal_info) << "loading graphics in Game" << endl;
             core_->loadGraphics();
             Loki::ScopeGuard graphicsUnloader = Loki::MakeObjGuard(*this, &Game::unloadGraphics);
 …
+            }
             graphicsUnloader.Dismiss();
+            orxout(internal_info) << "finished loading graphics in Game" << endl;
+        }
+    }
 …
         if (GameMode::showsGraphics())
+        {
+            orxout(user_status) << "Unloading graphics" << endl;
+            orxout(internal_info) << "unloading graphics in Game" << endl;
             // Destroy all the GameStates that require graphics
             for (GameStateMap::iterator it = constructedStates_.begin(); it != constructedStates_.end();)
 …
     void Game::loadState(const std::string& name)
+    {
+        orxout(internal_status) << "loading state '" << name << "'" << endl;
         this->bChangingState_ = true;
         LOKI_ON_BLOCK_EXIT_OBJ(*this, &Game::resetChangingState); (void)LOKI_ANONYMOUS_VARIABLE(scopeGuard);
 …
     void Game::unloadState(const std::string& name)
+    {
+        orxout(internal_status) << "unloading state '" << name << "'" << endl;
         this->bChangingState_ = true;
         try
 …
         catch (...)
+        {
             COUT(2) << "Warning: Unloading GameState '" << name << "' threw an exception: " << Exception::handleMessage() << std::endl;
             COUT(2) << "         There might be potential resource leaks involved! To avoid this, improve exception-safety." << std::endl;
+            orxout(internal_warning) << "Unloading GameState '" << name << "' threw an exception: " << Exception::handleMessage() << endl;
+            orxout(internal_warning) << "There might be potential resource leaks involved! To avoid this, improve exception-safety." << endl;
+        }
         // Check if graphics is still required

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

-                      r8423
+                      r8858
 #include <boost/preprocessor/cat.hpp>
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "util/DestructionHelper.h"
 #include "util/Singleton.h"
 …
         else
+        {
             COUT(0) << "Error: Cannot declare two GameStates with the same name." << std::endl;
             COUT(0) << "       Ignoring second one ('" << stateName << "')." << std::endl;
+            orxout(internal_warning) << "Cannot declare two GameStates with the same name." << endl;
+            orxout(internal_warning) << "Ignoring second one ('" << stateName << "')." << endl;
+        }

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

r6417	r8858
35	35	#include "GameState.h"
36	36
37		~~#include "util/Debug.h"~~
38	37	#include "util/Exception.h"
39	38	#include "util/OrxAssert.h"

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

-                      r8423
+                      r8858
         RegisterObject(GraphicsManager);
+        orxout(internal_status) << "initializing GraphicsManager..." << endl;
         this->setConfigValues();
 …
         resources_.reset(new XMLFile("DefaultResources.oxr"));
         resources_->setLuaSupport(false);
         Loader::open(resources_.get());
+        Loader::open(resources_.get(), ClassTreeMask(), false);
         // Only for runs in the build directory (not installed)
 …
         extResources_.reset(new XMLFile("resources.oxr"));
         extResources_->setLuaSupport(false);
         Loader::open(extResources_.get());
+        Loader::open(extResources_.get(), ClassTreeMask(), false);
         if (bLoadRenderer)
 …
             this->upgradeToGraphics();
+        }
+        orxout(internal_status) << "finished initializing GraphicsManager" << endl;
+    }
     void GraphicsManager::destroy()
+    {
+        orxout(internal_status) << "destroying GraphicsManager..." << endl;
         Loader::unload(debugOverlay_.get());
 …
         safeObjectDelete(&ogreLogger_);
         safeObjectDelete(&ogreWindowEventListener_);
+        orxout(internal_status) << "finished destroying GraphicsManager" << endl;
+    }
 …
         SetConfigValue(ogreLogFile_,     "ogre.log")
             .description("Logfile for messages from Ogre. Use \"\" to suppress log file creation.");
-        SetConfigValue(ogreLogLevelTrivial_ , 5)
-            .description("Corresponding orxonox debug level for ogre Trivial");
-        SetConfigValue(ogreLogLevelNormal_  , 4)
-            .description("Corresponding orxonox debug level for ogre Normal");
-        SetConfigValue(ogreLogLevelCritical_, 2)
-            .description("Corresponding orxonox debug level for ogre Critical");
+    }
 …
             return;
+        orxout(internal_info) << "GraphicsManager upgrade to graphics" << endl;
         // load all the required plugins for Ogre
         this->loadOgrePlugins();
 …
         // choose another resource group.
         Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
+        orxout(internal_info) << "GraphicsManager finished upgrade to graphics" << endl;
+    }
 …
     void GraphicsManager::loadOgreRoot()
+    {
         COUT(3) << "Setting up Ogre..." << std::endl;
+        orxout(internal_info) << "Setting up Ogre..." << endl;
         if (ogreConfigFile_.empty())
+        {
             COUT(2) << "Warning: Ogre config file set to \"\". Defaulting to config.cfg" << std::endl;
+            orxout(internal_warning) << "Ogre config file set to \"\". Defaulting to config.cfg" << endl;
             ModifyConfigValue(ogreConfigFile_, tset, "config.cfg");
+        }
         if (ogreLogFile_.empty())
+        {
             COUT(2) << "Warning: Ogre log file set to \"\". Defaulting to ogre.log" << std::endl;
+            orxout(internal_warning) << "Ogre log file set to \"\". Defaulting to ogre.log" << endl;
             ModifyConfigValue(ogreLogFile_, tset, "ogre.log");
+        }
 …
         // Ogre::Root will detect that we've already created a Log
         ogreLogger_ = new Ogre::LogManager();
         COUT(4) << "Ogre LogManager created" << std::endl;
+        orxout(internal_info) << "Ogre LogManager created" << endl;
         // create our own log that we can listen to
         Ogre::Log *myLog;
         myLog = ogreLogger_->createLog(ogreLogFilepath.string(), true, false, false);
         COUT(4) << "Ogre Log created" << std::endl;
+        orxout(internal_info) << "Ogre Log created" << endl;
         myLog->setLogDetail(Ogre::LL_BOREME);
         myLog->addListener(this);
         COUT(4) << "Creating Ogre Root..." << std::endl;
+        orxout(internal_info) << "Creating Ogre Root..." << endl;
         // check for config file existence because Ogre displays (caught) exceptions if not
 …
         ogreRoot_ = new Ogre::Root("", ogreConfigFilepath.string(), ogreLogFilepath.string());
         COUT(3) << "Ogre set up done." << std::endl;
+        orxout(internal_info) << "Ogre set up done." << endl;
+    }
     void GraphicsManager::loadOgrePlugins()
+    {
+        orxout(internal_info) << "loading ogre plugins" << endl;
         // Plugin path can have many different locations...
         std::string pluginPath = specialConfig::ogrePluginsDirectory;
 …
     void GraphicsManager::loadRenderer()
+    {
         CCOUT(4) << "Configuring Renderer" << std::endl;
+        orxout(internal_info) << "GraphicsManager: Configuring Renderer" << endl;
         bool updatedConfig = Core::getInstance().getOgreConfigTimestamp() > Core::getInstance().getLastLevelTimestamp();
         if (updatedConfig)
             COUT(2) << "Ogre config file has changed, but no level was started since then. Displaying config dialogue again to verify the changes." << std::endl;
+            orxout(user_info)<< "Ogre config file has changed, but no level was started since then. Displaying config dialogue again to verify the changes." << endl;
         if (!ogreRoot_->restoreConfig() || updatedConfig)
 …
+        }
         CCOUT(4) << "Creating render window" << std::endl;
+        orxout(internal_info) << "Creating render window" << endl;
         this->renderWindow_ = ogreRoot_->initialise(true, "Orxonox");
 …
+    {
         // Load debug overlay to show info about fps and tick time
         COUT(4) << "Loading Debug Overlay..." << std::endl;
+        orxout(internal_info) << "Loading Debug Overlay..." << endl;
         debugOverlay_.reset(new XMLFile("debug.oxo"));
         Loader::open(debugOverlay_.get());
+        Loader::open(debugOverlay_.get(), ClassTreeMask(), false);
+    }
 …
         Ogre::LogMessageLevel lml, bool maskDebug, const std::string& logName)
+    {
         int orxonoxLevel;
+        OutputLevel orxonoxLevel;
         std::string introduction;
         // Do not show caught OGRE exceptions in front
         if (message.find("EXCEPTION") != std::string::npos)
+        {
             orxonoxLevel = OutputLevel::Debug;
+            orxonoxLevel = level::internal_error;
             introduction = "Ogre, caught exception: ";
+        }
 …
+            {
             case Ogre::LML_TRIVIAL:
                 orxonoxLevel = this->ogreLogLevelTrivial_;
+                orxonoxLevel = level::verbose_more;
                 break;
             case Ogre::LML_NORMAL:
                 orxonoxLevel = this->ogreLogLevelNormal_;
+                orxonoxLevel = level::verbose;
                 break;
             case Ogre::LML_CRITICAL:
                 orxonoxLevel = this->ogreLogLevelCritical_;
+                orxonoxLevel = level::internal_warning;
                 break;
             default:
                 orxonoxLevel = 0;
+                orxonoxLevel = level::debug_output;
+            }
             introduction = "Ogre: ";
+        }
+        OutputHandler::getOutStream(orxonoxLevel)
             << introduction << message << std::endl;
+        orxout(orxonoxLevel, context::ogre) << introduction << message << endl;
+    }

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

-                      r8706
+                      r8858
         std::string         ogrePlugins_;              //!< Comma separated list of all plugins to load
         std::string         ogreLogFile_;              //!< log filename for Ogre log messages
-        int                 ogreLogLevelTrivial_;      //!< Corresponding Orxonox debug level for LL_TRIVIAL
-        int                 ogreLogLevelNormal_;       //!< Corresponding Orxonox debug level for LL_NORMAL
-        int                 ogreLogLevelCritical_;     //!< Corresponding Orxonox debug level for LL_CRITICAL
         /// Helper object that executes the surrogate destructor destroy()

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

r8267	r8858
130	130	{
131	131	// If no: We have to store the information and initialize the Identifier
132		~~COUT(4) << "*** ClassIdentifier: Register Class in " << this->getName() << "-Singleton -> Initialize Singleton." << std::~~endl;
	132	orxout(verbose, context::identifier) << "Register Class in ClassIdentifier<" << this->getName() << ">-Singleton -> Initialize Singleton." << endl;
133	133	if (bRootClass)
134	134	this->initialize(0); // If a class is derived from two interfaces, the second interface might think it's derived from the first because of the order of constructor-calls. Thats why we set parents to zero in that case.
…	…
144	144	void Identifier::initialize(std::set<const Identifier> parents)
145	145	{
146		~~COUT(4) << "*** Identifier: Initialize " << this->name_ << "-Singleton." << std::~~endl;
	146	orxout(verbose, context::identifier) << "Initialize ClassIdentifier<" << this->name_ << ">-Singleton." << endl;
147	147	this->bCreatedOneObject_ = true;
148	148
…	…
191	191	void Identifier::createClassHierarchy()
192	192	{
193		~~COUT(3) << "*** Identifier: Create class-hierarchy" << std::~~endl;
	193	orxout(internal_status) << "Create class-hierarchy" << endl;
194	194	Identifier::startCreatingHierarchy();
195	195	for (std::map<std::string, Identifier*>::const_iterator it = Identifier::getStringIdentifierMap().begin(); it != Identifier::getStringIdentifierMap().end(); ++it)
…	…
203	203	}
204	204	Identifier::stopCreatingHierarchy();
205		~~COUT(3) << "*** Identifier: Finished class-hierarchy creation" << std::~~endl;
	205	orxout(internal_status) << "Finished class-hierarchy creation" << endl;
206	206	}
207	207
…	…
242	242	else
243	243	{
244		~~COUT(1) << "An error occurred in Identifier.cc:" << std::~~endl;
245		~~COUT(1) << "Error: Cannot fabricate an object of type '" << this->name_ << "'. Class has no factory." << std::~~endl;
246		~~COUT(1) << "Aborting..." << std::~~endl;
	244	orxout(user_error) << "An error occurred in Identifier.cc:" << endl;
	245	orxout(user_error) << "Cannot fabricate an object of type '" << this->name_ << "'. Class has no factory." << endl;
	246	orxout(user_error) << "Aborting..." << endl;
247	247	abort();
248	248	return 0;
…	…
404	404	if (it != this->configValues_.end())
405	405	{
406		~~COUT(2) << "Warning: Overwriting config-value with name " << varname << " in class " << this->getName() << '.' << std::~~endl;
	406	orxout(internal_warning) << "Overwriting config-value with name " << varname << " in class " << this->getName() << '.' << endl;
407	407	delete (it->second);
408	408	}
…	…
450	450	if (it != this->xmlportParamContainers_.end())
451	451	{
452		~~COUT(2) << "Warning: Overwriting XMLPortParamContainer in class " << this->getName() << '.' << std::~~endl;
	452	orxout(internal_warning) << "Overwriting XMLPortParamContainer in class " << this->getName() << '.' << endl;
453	453	delete (it->second);
454	454	}
…	…
481	481	if (it != this->xmlportObjectContainers_.end())
482	482	{
483		~~COUT(2) << "Warning: Overwriting XMLPortObjectContainer in class " << this->getName() << '.' << std::~~endl;
	483	orxout(internal_warning) << "Overwriting XMLPortObjectContainer in class " << this->getName() << '.' << endl;
484	484	delete (it->second);
485	485	}

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

-                      r8706
+                      r8858
     for (Iterator<BaseObject> it = objects.begin(); it != objects.end(); ++it)  // iterate through the objects
         ++count;
     COUT(0) << count << std::endl;                                              // prints "2" because we created 2 instances of MyClass so far
+    orxout() << count << endl;                                                  // prints "2" because we created 2 instances of MyClass so far
 …
 #include <loki/TypeTraits.h>
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "MetaObjectList.h"
 #include "ObjectList.h"
 …
         if (ClassIdentifier<T>::classIdentifier_s == proposal)
+        {
             COUT(4) << "*** Identifier: Requested Identifier for " << name << " was not yet existing and got created." << std::endl;
+            orxout(verbose, context::identifier) << "Requested Identifier for " << name << " was not yet existing and got created." << endl;
+        }
         else
+        {
             COUT(4) << "*** Identifier: Requested Identifier for " << name << " was already existing and got assigned." << std::endl;
+            orxout(verbose, context::identifier) << "Requested Identifier for " << name << " was already existing and got assigned." << endl;
+        }
+    }
 …
+    {
         if (bRootClass)
             COUT(5) << "*** Register Root-Object: " << className << std::endl;
+            orxout(verbose, context::object_list) << "Register Root-Object: " << className << endl;
         else
             COUT(5) << "*** Register Object: " << className << std::endl;
+            orxout(verbose, context::object_list) << "Register Object: " << className << endl;
         object->identifier_ = this;
 …
         else
+        {
             COUT(5) << "*** ClassIdentifier: Added object to " << this->getName() << "-list." << std::endl;
+            orxout(verbose, context::object_list) << "Added object to " << this->getName() << "-list." << endl;
             object->metaList_->add(this->objects_, this->objects_->add(new ObjectListElement<T>(object)));

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

r7401	r8858
35	35
36	36	#include <fstream>
37		#include "util/~~Debug~~.h"
	37	#include "util/Output.h"
38	38	#include "util/StringUtils.h"
39	39	#include "Core.h"
…	…
131	131	}
132	132
133		~~COUT(2) << "Warning: Language entry " << label << " is duplicate in " << getFilename(this->defaultLanguage_) << '!' << std::~~endl;
	133	orxout(internal_warning, context::language) << "Language entry " << label << " is duplicate in " << getFilename(this->defaultLanguage_) << '!' << endl;
134	134	return it->second;
135	135	}
…	…
142	142	void Language::addEntry(const LanguageEntryLabel& label, const std::string& entry)
143	143	{
144		~~COUT(5) << "Language: Called addEntry with\n label: " << label << "\n entry: " << entry << std::~~endl;
	144	orxout(verbose, context::language) << "Called addEntry with" << '\n' << "label: " << label << '\n' << "entry: " << entry << endl;
145	145	std::map<std::string, LanguageEntry*>::const_iterator it = this->languageEntries_.find(label);
146	146	if (it == this->languageEntries_.end())
…	…
179	179	{
180	180	// Uh, oh, an undefined entry was requested: return the default string
181		~~COUT(2) << "Warning: Language entry \"" << label << "\" not found!" << std::~~endl;
	181	orxout(internal_warning, context::language) << "Language entry \"" << label << "\" not found!" << endl;
182	182	return this->defaultLocalisation_;
183	183	}
…	…
201	201	void Language::readDefaultLanguageFile()
202	202	{
203		~~COUT(4) << "Read default language file." << std::~~endl;
	203	orxout(internal_info, context::language) << "Read default language file." << endl;
204	204
205	205	const std::string& filepath = PathConfig::getConfigPathString() + getFilename(this->defaultLanguage_);
…	…
216	216	if (!file.is_open())
217	217	{
218		~~COUT(1) << "An error occurred in Language.cc:" << std::~~endl;
219		~~COUT(1) << "Error: Couldn't open file " << getFilename(this->defaultLanguage_) << " to read the default language entries!" << std::~~endl;
	218	orxout(internal_error, context::language) << "An error occurred in Language.cc:" << endl;
	219	orxout(internal_error, context::language) << "Couldn't open file " << getFilename(this->defaultLanguage_) << " to read the default language entries!" << endl;
220	220	return;
221	221	}
…	…
237	237	else
238	238	{
239		~~COUT(2) << "Warning: Invalid language entry \"" << lineString << "\" in " << getFilename(this->defaultLanguage_) << std::~~endl;
	239	orxout(internal_warning, context::language) << "Invalid language entry \"" << lineString << "\" in " << getFilename(this->defaultLanguage_) << endl;
240	240	}
241	241	}
…	…
250	250	void Language::readTranslatedLanguageFile()
251	251	{
252		~~COUT(4) << "Read translated language file (" << Core::getInstance().getLanguage() << ")." << std::~~endl;
	252	orxout(internal_info, context::language) << "Read translated language file (" << Core::getInstance().getLanguage() << ")." << endl;
253	253
254	254	const std::string& filepath = PathConfig::getConfigPathString() + getFilename(Core::getInstance().getLanguage());
…	…
260	260	if (!file.is_open())
261	261	{
262		~~COUT(1) << "An error occurred in Language.cc:" << std::~~endl;
263		~~COUT(1) << "Error: Couldn't open file " << getFilename(Core::getInstance().getLanguage()) << " to read the translated language entries!" << std::~~endl;
	262	orxout(internal_error, context::language) << "An error occurred in Language.cc:" << endl;
	263	orxout(internal_error, context::language) << "Couldn't open file " << getFilename(Core::getInstance().getLanguage()) << " to read the translated language entries!" << endl;
264	264	Core::getInstance().resetLanguage();
265		~~COUT(3) << "Info: Reset language to " << this->defaultLanguage_ << '.' << std::~~endl;
	265	orxout(internal_info, context::language) << "Reset language to " << this->defaultLanguage_ << '.' << endl;
266	266	return;
267	267	}
…	…
291	291	else
292	292	{
293		~~COUT(2) << "Warning: Invalid language entry \"" << lineString << "\" in " << getFilename(Core::getInstance().getLanguage()) << std::~~endl;
	293	orxout(internal_warning, context::language) << "Invalid language entry \"" << lineString << "\" in " << getFilename(Core::getInstance().getLanguage()) << endl;
294	294	}
295	295	}
…	…
304	304	void Language::writeDefaultLanguageFile() const
305	305	{
306		~~COUT(4) << "Language: Write default language file." << std::~~endl;
	306	orxout(verbose, context::language) << "Write default language file." << endl;
307	307
308	308	const std::string& filepath = PathConfig::getConfigPathString() + getFilename(this->defaultLanguage_);
…	…
314	314	if (!file.is_open())
315	315	{
316		~~COUT(1) << "An error occurred in Language.cc:" << std::~~endl;
317		~~COUT(1) << "Error: Couldn't open file " << getFilename(this->defaultLanguage_) << " to write the default language entries!" << std::~~endl;
	316	orxout(internal_error, context::language) << "An error occurred in Language.cc:" << endl;
	317	orxout(internal_error, context::language) << "Couldn't open file " << getFilename(this->defaultLanguage_) << " to write the default language entries!" << endl;
318	318	return;
319	319	}
…	…
322	322	for (std::map<std::string, LanguageEntry*>::const_iterator it = this->languageEntries_.begin(); it != this->languageEntries_.end(); ++it)
323	323	{
324		file << it->second->getLabel() << '=' << it->second->getDefault() << ~~std::~~endl;
	324	file << it->second->getLabel() << '=' << it->second->getDefault() << endl;
325	325	}
326	326

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

-                      r7401
+                      r8858
      - Get the localisation of the entry in the configured language:
        @code
        std::cout << Language::getInstance()->getLocalisation("name of the entry") << std::endl;
+       orxout() << Language::getInstance()->getLocalisation("name of the entry") << endl;
        @endcode
 …
     int age = 20;
     AddLanguageEntry("user_age", "Age");
     std::cout << GetLocalisation("user_age") << ": " << age << std::endl;
+    orxout() << GetLocalisation("user_age") << ": " << age << endl;
     @endcode

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

-                      r8108
+                      r8858
 #include <boost/scoped_ptr.hpp>
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "util/Exception.h"
 #include "util/StringUtils.h"
 …
     ClassTreeMask Loader::currentMask_s;
     bool Loader::open(const XMLFile* file, const ClassTreeMask& mask)
+    bool Loader::open(const XMLFile* file, const ClassTreeMask& mask, bool bVerbose)
+    {
         Loader::add(file, mask);
         return Loader::load(file, mask);
+        return Loader::load(file, mask, bVerbose);
+    }
 …
     @param mask
         A ClassTreeMask, which defines which types of classes are loaded and which aren't.
     @param verbose
+    @param bVerbose
         Whether the loader is verbose (prints its progress in a low output level) or not.
     @return
         Returns true if successful.
     */
     bool Loader::load(const ClassTreeMask& mask, bool verbose)
+    bool Loader::load(const ClassTreeMask& mask, bool bVerbose)
+    {
         bool success = true;
         for (std::vector<std::pair<const XMLFile*, ClassTreeMask> >::iterator it = Loader::files_s.begin(); it != Loader::files_s.end(); ++it)
             if (!Loader::load(it->first, it->second * mask, verbose))
+            if (!Loader::load(it->first, it->second * mask, bVerbose))
                 success = false;
 …
     @param mask
         A ClassTreeMask, which defines which types of classes are reloaded and which aren't.
     @param verbose
+    @param bVerbose
         Whether the loader is verbose (prints its progress in a low output level) or not.
     @return
         Returns true if successful.
     */
     bool Loader::reload(const ClassTreeMask& mask, bool verbose)
+    bool Loader::reload(const ClassTreeMask& mask, bool bVerbose)
+    {
         Loader::unload(mask);
         return Loader::load(mask, verbose);
+        return Loader::load(mask, bVerbose);
+    }
 …
     @param mask
         A ClassTreeMask, which defines which types of classes are loaded and which aren't.
     @param verbose
+    @param bVerbose
         Whether the loader is verbose (prints its progress in a low output level) or not.
     @param bRemoveLuaTags
 …
         Returns true if successful.
     */
     bool Loader::load(const XMLFile* file, const ClassTreeMask& mask, bool verbose, bool bRemoveLuaTags)
+    bool Loader::load(const XMLFile* file, const ClassTreeMask& mask, bool bVerbose, bool bRemoveLuaTags)
+    {
         if (!file)
 …
             if (info == NULL)
+            {
                 COUT(1) << "Error: Could not find XML file '" << file->getFilename() << "'." << std::endl;
+                orxout(user_error, context::loader) << "Could not find XML file '" << file->getFilename() << "'." << endl;
                 return false;
+            }
 …
         try
+        {
             if(verbose)
+            {
                 COUT(0) << "Start loading " << file->getFilename() << "..." << std::endl;
                 COUT(3) << "Mask: " << Loader::currentMask_s << std::endl;
+            }
             else
+            {
                 COUT(4) << "Start loading " << file->getFilename() << "..." << std::endl;
                 COUT(4) << "Mask: " << Loader::currentMask_s << std::endl;
+            if(bVerbose)
+            {
+                orxout(user_info) << "Start loading " << file->getFilename() << "..." << endl;
+                orxout(internal_info, context::loader) << "Mask: " << Loader::currentMask_s << endl;
+            }
+            else
+            {
+                orxout(verbose, context::loader) << "Start loading " << file->getFilename() << "..." << endl;
+                orxout(verbose_more, context::loader) << "Mask: " << Loader::currentMask_s << endl;
+            }
 …
                 rootElement.InsertEndChild(*child);
             COUT(4) << "  creating root-namespace..." << std::endl;
+            orxout(verbose, context::loader) << "  creating root-namespace..." << endl;
             Namespace* rootNamespace = new Namespace(0);
             rootNamespace->setLoaderIndentation("    ");
 …
             rootNamespace->XMLPort(rootElement, XMLPort::LoadObject);
             if(verbose)
                 COUT(0) << "Finished loading " << file->getFilename() << '.' << std::endl;
             else
                 COUT(4) << "Finished loading " << file->getFilename() << '.' << std::endl;
             COUT(4) << "Namespace-tree:" << std::endl << rootNamespace->toString("  ") << std::endl;
+            if(bVerbose)
+                orxout(user_info) << "Finished loading " << file->getFilename() << '.' << endl;
+            else
+                orxout(verbose, context::loader) << "Finished loading " << file->getFilename() << '.' << endl;
+            orxout(verbose, context::loader) << "Namespace-tree:" << '\n' << rootNamespace->toString("  ") << endl;
             return true;
 …
         catch (ticpp::Exception& ex)
+        {
             COUT(1) << std::endl;
             COUT(1) << "An XML-error occurred in Loader.cc while loading " << file->getFilename() << ':' << std::endl;
             COUT(1) << ex.what() << std::endl;
             COUT(1) << "Loading aborted." << std::endl;
+            orxout(user_error, context::loader) << endl;
+            orxout(user_error, context::loader) << "An XML-error occurred in Loader.cc while loading " << file->getFilename() << ':' << endl;
+            orxout(user_error, context::loader) << ex.what() << endl;
+            orxout(user_error, context::loader) << "Loading aborted." << endl;
             return false;
+        }
         catch (Exception& ex)
+        {
             COUT(1) << std::endl;
             COUT(1) << "A loading-error occurred in Loader.cc while loading " << file->getFilename() << ':' << std::endl;
             COUT(1) << ex.what() << std::endl;
             COUT(1) << "Loading aborted." << std::endl;
+            orxout(user_error, context::loader) << endl;
+            orxout(user_error, context::loader) << "A loading-error occurred in Loader.cc while loading " << file->getFilename() << ':' << endl;
+            orxout(user_error, context::loader) << ex.what() << endl;
+            orxout(user_error, context::loader) << "Loading aborted." << endl;
             return false;
+        }
         catch (...)
+        {
             COUT(1) << std::endl;
             COUT(1) << "An error occurred in Loader.cc while loading " << file->getFilename() << ':' << std::endl;
             COUT(1) << Exception::handleMessage() << std::endl;
             COUT(1) << "Loading aborted." << std::endl;
+            orxout(user_error, context::loader) << endl;
+            orxout(user_error, context::loader) << "An error occurred in Loader.cc while loading " << file->getFilename() << ':' << endl;
+            orxout(user_error, context::loader) << Exception::handleMessage() << endl;
+            orxout(user_error, context::loader) << "Loading aborted." << endl;
             return false;
+        }
 …
     @param mask
         A ClassTreeMask, which defines which types of classes are reloaded and which aren't.
     @param verbose
+    @param bVerbose
         Whether the loader is verbose (prints its progress in a low output level) or not.
     @return
         Returns true if successful.
     */
     bool Loader::reload(const XMLFile* file, const ClassTreeMask& mask, bool verbose)
+    bool Loader::reload(const XMLFile* file, const ClassTreeMask& mask, bool bVerbose)
+    {
         Loader::unload(file, mask);
         return Loader::load(file, mask, verbose);
+        return Loader::load(file, mask, bVerbose);
+    }
 …
             if (!expectedValue)
+            {
                 COUT(2) << "Warning: Error in level file" << std::endl;
+                orxout(internal_error, context::loader) << "Error in level file" << endl;
                 // TODO: error handling
                 return false;
+                return false;
+            }
+        }

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

-                      r8079
+                      r8858
+    {
         public:
             static bool open(const XMLFile* file, const ClassTreeMask& mask = ClassTreeMask());
+            static bool open(const XMLFile* file, const ClassTreeMask& mask = ClassTreeMask(), bool bVerbose = true);
             static void close();
             static void close(const XMLFile* file);
 …
             static void remove(const XMLFile* file);
             static bool load(const ClassTreeMask& mask = ClassTreeMask(), bool verbose = true);
+            static bool load(const ClassTreeMask& mask = ClassTreeMask(), bool bVerbose = true);
             static void unload(const ClassTreeMask& mask = ClassTreeMask());
             static bool reload(const ClassTreeMask& mask = ClassTreeMask(), bool verbose = true);
+            static bool reload(const ClassTreeMask& mask = ClassTreeMask(), bool bVerbose = true);
             static bool load(const XMLFile* file, const ClassTreeMask& mask = ClassTreeMask(),
                              bool verbose = true, bool bRemoveLuaTags = false);
+                             bool bVerbose = true, bool bRemoveLuaTags = false);
             static void unload(const XMLFile* file, const ClassTreeMask& mask = ClassTreeMask());
             static bool reload(const XMLFile* file, const ClassTreeMask& mask = ClassTreeMask(), bool verbose = true);
+            static bool reload(const XMLFile* file, const ClassTreeMask& mask = ClassTreeMask(), bool bVerbose = true);
             static std::string replaceLuaTags(const std::string& text);

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

-                      r8729
+                      r8858
 #include <loki/ScopeGuard.h>
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "util/Exception.h"
 #include "Resource.h"
 …
         else
+        {
             COUT(2) << "LuaState: Cannot include file '" << filename << "' (not found)." << std::endl;
+            orxout(internal_warning, context::lua) << "LuaState: Cannot include file '" << filename << "' (not found)." << endl;
             return false;
+        }
 …
         else
+        {
             COUT(2) << "LuaState: Cannot do file '" << filename << "' (not found)." << std::endl;
+            orxout(internal_warning, context::lua) << "LuaState: Cannot do file '" << filename << "' (not found)." << endl;
             return false;
+        }
 …
+        {
         case LUA_ERRSYNTAX: // Syntax error
             COUT(1) << "Lua syntax error: " << lua_tostring(luaState_, -1) << std::endl;
+            orxout(internal_error, context::lua) << "Lua syntax error: " << lua_tostring(luaState_, -1) << endl;
             break;
         case LUA_ERRMEM:    // Memory allocation error
             COUT(1) << "Lua memory allocation error: Consult your dentist immediately!" << std::endl;
+            orxout(internal_error, context::lua) << "Lua memory allocation error: Consult your dentist immediately!" << endl;
             break;
+        }
 …
                     std::string errorString = lua_tostring(this->luaState_, -1);
                     if (errorString.find("Error propagation") == std::string::npos)
                         COUT(1) << "Lua runtime error: " << errorString << std::endl;
+                        orxout(internal_error, context::lua) << "Lua runtime error: " << errorString << endl;
+                }
                 break;
             case LUA_ERRERR: // Error in the error handler
                 COUT(1) << "Lua error in error handler. No message available." << std::endl;
+                orxout(internal_error, context::lua) << "Lua error in error handler. No message available." << endl;
                 break;
             case LUA_ERRMEM: // Memory allocation error
                 COUT(1) << "Lua memory allocation error: Consult your dentist immediately!" << std::endl;
+                orxout(internal_error, context::lua) << "Lua memory allocation error: Consult your dentist immediately!" << endl;
                 break;
+            }
 …
+    }
+    void LuaState::luaLog(unsigned int level, const std::string& message)
+    {
+        OutputHandler::getOutStream(level) << message << std::endl;
+    void LuaState::luaOutput(OutputLevel level, const std::string& context, const std::string& message)
+    {
+        orxout(level, registerContext(context)) << message << endl;
+    }
+    void LuaState::luaOutput(OutputLevel level, const std::string& message)
+    {
+        orxout(level, context::lua) << message << endl;
+    }
+    void LuaState::luaOutput(const std::string& message)
+    {
+        orxout(debug_output, context::lua) << message << endl;
+    }
 …
             if (it->first == name || it->second == function)
+            {
                 COUT(2) << "Warning: Trying to add a Tolua interface with the same name or function." << std::endl;
+                orxout(internal_warning, context::lua) << "Trying to add a Tolua interface with the same name or function." << endl;
                 return true;
+            }
 …
         if (it == getToluaInterfaces().end())
+        {
             COUT(2) << "Warning: Cannot remove Tolua interface '" << name << "': Not found" << std::endl;
+            orxout(internal_warning, context::lua) << "Cannot remove Tolua interface '" << name << "': Not found" << endl;
             return true;
+        }

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

-                      r8729
+                      r8858
 #include <boost/shared_ptr.hpp>
+#include "util/Output.h"
 namespace orxonox // tolua_export
 { // tolua_export
 …
         void luaPrint(const std::string& str); // tolua_export
+        void luaLog(unsigned int level, const std::string& message); // tolua_export
+        void luaOutput(orxonox::level::OutputLevel level, const std::string& context, const std::string& message); // tolua_export
+        void luaOutput(orxonox::level::OutputLevel level, const std::string& message); // tolua_export
+        void luaOutput(const std::string& message); // tolua_export
         bool fileExists(const std::string& filename); // tolua_export
         std::string getSourceCode(const std::string& filename); // tolua_export

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

-                      r5738
+                      r8858
 #include "MetaObjectList.h"
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "Identifier.h"
 #include "ObjectListBase.h"
 …
     MetaObjectListElement::~MetaObjectListElement()
+    {
         COUT(5) << "*** MetaObjectList: Removing Object from " << this->list_->getIdentifier()->getName() << "-list." << std::endl;
+        orxout(verbose, context::object_list) << "Removing Object from " << this->list_->getIdentifier()->getName() << "-list." << endl;
         this->list_->notifyIterators(this->element_->objectBase_);

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

r6417	r8858
28	28
29	29	#include "NamespaceNode.h"
30		#include "util/~~Debug~~.h"
	30	#include "util/Output.h"
31	31
32	32	namespace orxonox
…	…
70	70	if (this->bRoot_)
71	71	{
72		~~COUT(2) << "Warning: Can't go to enclosing namespace with '..' operator in namespace " << this->name_ << ", namespace is root." << std::~~endl;
	72	orxout(internal_warning) << "Can't go to enclosing namespace with '..' operator in namespace " << this->name_ << ", namespace is root." << endl;
73	73	nodes = this->getNodeRelative(secondPart);
74	74	}
75	75	else if (!this->parent_)
76	76	{
77		~~COUT(2) << "Warning: Can't go to enclosing namespace with '..' operator in namespace " << this->name_ << ", no parent namespace set." << std::~~endl;
	77	orxout(internal_warning) << "Can't go to enclosing namespace with '..' operator in namespace " << this->name_ << ", no parent namespace set." << endl;
78	78	nodes = this->getNodeRelative(secondPart);
79	79	}
…	…
91	91	if (it->second->isHidden())
92	92	{
93		~~COUT(2) << "Warning: Subnamespace '" << firstPart << "' in namespace '" << this->name_ << "' is hidden and can't be accessed." << std::~~endl;
	93	orxout(internal_warning) << "Subnamespace '" << firstPart << "' in namespace '" << this->name_ << "' is hidden and can't be accessed." << endl;
94	94	nodes.insert(this);
95	95	}
…	…
115	115	if (!bFoundMatchingNamespace)
116	116	{
117		~~COUT(2) << "Warning: No file included with name '" << firstPart.substr(1, std::string::npos) << "' at this part of the level file, using parent namespace instead." << std::~~endl;
	117	orxout(internal_warning) << "No file included with name '" << firstPart.substr(1, std::string::npos) << "' at this part of the level file, using parent namespace instead." << endl;
118	118	nodes = this->getNodeRelative(secondPart);
119	119	}

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

r7849	r8858
60	60	{
61	61	// if (!this->requestedDestruction_)
62		// ~~COUT(2) << "Warning: Destroyed object without destroy() (" << this->getIdentifier()->getName() << ')' << std::~~endl;
	62	// orxout(internal_warning) << "Destroyed object without destroy() (" << this->getIdentifier()->getName() << ')' << endl;
63	63
64	64	assert(this->referenceCount_ <= 0);

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

-                      r8729
+                      r8858
 #include <vector>
 #include "Super.h"
-/**
-@def CCOUT
-    Acts almost exactly like COUT(x), but prepends "ClassName: "
-*/
-#define CCOUT(level) \
-    COUT(level) << this->getIdentifier()->getName() << ": "
 namespace orxonox

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

-                      r8729
+                      r8858
 #include "SpecialConfig.h"
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "util/Exception.h"
 #include "CommandLineParser.h"
 …
         if (bf::exists(executablePath_ / "orxonox_dev_build.keep_me"))
+        {
             COUT(1) << "Running from the build tree." << std::endl;
+            orxout(internal_info) << "Running from the build tree." << endl;
             PathConfig::bBuildDirectoryRun_ = true;
             modulePath_ = specialConfig::moduleDevDirectory;
 …
             if (bf::create_directories(it->first)) // function may not return true at all (bug?)
+            {
                 COUT(4) << "Created " << it->second << " directory" << std::endl;
+                orxout(internal_info) << "Created " << it->second << " directory" << endl;
+            }
+        }

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

-                      r7401
+                      r8858
 #include <cstdlib>
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "Identifier.h"
 …
                 if (!identifier || !identifier->isA(ClassIdentifier<T>::getIdentifier()))
+                {
                     COUT(1) << "An error occurred in SubclassIdentifier (Identifier.h):" << std::endl;
+                    orxout(internal_error) << "An error occurred in SubclassIdentifier (Identifier.h):" << 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;
+                        orxout(internal_error) << "Class " << identifier->getName() << " is not a " << ClassIdentifier<T>::getIdentifier()->getName() << '!' << endl;
+                        orxout(internal_error) << "SubclassIdentifier<" << ClassIdentifier<T>::getIdentifier()->getName() << "> = Class(" << identifier->getName() << ") is forbidden." << endl;
+                    }
                     else
+                    {
                         COUT(1) << "Error: Can't assign NULL identifier" << std::endl;
+                        orxout(internal_error) << "Can't assign NULL identifier" << endl;
+                    }
+                }
 …
                     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;
+                        orxout(user_error) << "An error occurred in SubclassIdentifier (Identifier.h):" << endl;
+                        orxout(user_error) << "Class " << this->identifier_->getName() << " is not a " << ClassIdentifier<T>::getIdentifier()->getName() << '!' << endl;
+                        orxout(user_error) << "Couldn't fabricate a new Object." << 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;
+                        orxout(user_error) << "An error occurred in SubclassIdentifier (Identifier.h):" << endl;
+                        orxout(user_error) << "Couldn't fabricate a new Object - Identifier is undefined." << endl;
+                    }
+                    orxout(user_error) << "Aborting..." << endl;
                     abort();
                     return 0;

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

-                      r8729
+                      r8858
 #include "CorePrereqs.h"
 #include "util/Debug.h"
+#include "util/Output.h"
 ///////////////////////
 …
                     if (!((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_) \
                     { \
                         COUT(5) << "Added SuperFunctionCaller for " << #functionname << ": " << ClassIdentifier<T>::getIdentifier()->getName() << " <- " << ((ClassIdentifier<T>*)(*it))->getName() << std::endl; \
+                        orxout(verbose, context::super) << "Added SuperFunctionCaller for " << #functionname << ": " << ClassIdentifier<T>::getIdentifier()->getName() << " <- " << ((ClassIdentifier<T>*)(*it))->getName() << endl; \
                         ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_ = new SuperFunctionClassCaller_##functionname <T>; \
                     } \
 …
+                    {
                         // Add the SuperFunctionCaller
                         COUT(5) << "adding functionpointer to " << ((ClassIdentifier<T>*)(*it))->getName() << std::endl;
+                        orxout(verbose, context::super) << "adding functionpointer to " << ((ClassIdentifier<T>*)(*it))->getName() << endl;
                         ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_ = new SuperFunctionClassCaller_##functionname <T>;
+                    }

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

r7163	r8858
32	32	#include <tinyxml/ticpp.h>
33	33
34		#include "util/~~Debug~~.h"
	34	#include "util/Output.h"
35	35	#include "CoreIncludes.h"
36	36	#include "XMLPort.h"
…	…
88	88	it = Template::getTemplateMap().find(this->getName());
89	89	if (it != Template::getTemplateMap().end())
90		~~COUT(2) << "Warning: Template with name \"" << this->getName() << "\" already exists." << std::~~endl;
	90	orxout(internal_warning, context::templates) << "Template with name \"" << this->getName() << "\" already exists." << endl;
91	91	else
92	92	Template::getTemplateMap()[this->getName()] = this;
…	…
117	117	else
118	118	{
119		~~COUT(2) << "Warning: Linking from " << this->getName() << " to " << this->link_ << " leads to an infinite loop. Returning own element." << std::~~endl;
	119	orxout(internal_warning, context::templates) << "Linking from \"" << this->getName() << "\" to \"" << this->link_ << "\" leads to an infinite loop. Returning own element." << endl;
120	120	}
121	121	}
122	122	else
123	123	{
124		~~COUT(2) << "Warning: " << this->link_ << " is not an existing Template name. Returning own element." << std::~~endl;
	124	orxout(internal_warning, context::templates) << '"' << this->link_ << "\" is not an existing Template name. Returning own element." << endl;
125	125	}
126	126	}
…	…
142	142	if (!object->isA(this->baseclassIdentifier_))
143	143	{
144		COUT(1) << "Error: Can't apply template (name: " << this->getName() << "), object (name: " << object->getName() << ", class: " << object->getIdentifier()->getName() << ") is not a " << this->baseclassIdentifier_->getName() << std::endl;
	144	orxout(internal_error, context::templates) << "Can't apply template (name: " << this->getName() << "), object (name: " << object->getName() << ", class: " << object->getIdentifier()->getName() << ") is not a " << this->baseclassIdentifier_->getName() << endl;
145	145	return;
146	146	}
147	147	}
148	148
149		~~COUT(4) << object->getLoaderIndentation() << " aplying Template \"" << this->getName() << "\"..." << std::~~endl;
	149	orxout(verbose, context::templates) << object->getLoaderIndentation() << " aplying Template \"" << this->getName() << "\"..." << endl;
150	150
151	151	Element temp = &const_cast<TiXmlElement&>(this->getXMLElement());
…	…
170	170	else
171	171	{
172		~~COUT(2) << "Warning: Template with name " << name << " doesn't exist." << std::~~endl;
	172	orxout(internal_warning, context::templates) << "Template with name " << name << " doesn't exist." << endl;
173	173	return 0;
174	174	}

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

r8079	r8858
65	65	void myCallback() // definition of the callback function
66	66	{
67		~~COUT(0) << "Object destroyed" << std::~~endl;
	67	orxout() << "Object destroyed" << endl;
68	68	}
69	69

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

r7163	r8858
64	64	if (!this->sectionname_.empty())
65	65	{
66		~~COUT(2) << object->getLoaderIndentation() << "Warning: '" << child->Value() << "' is not a valid classname." << std::~~endl;
	66	orxout(internal_warning, context::xml) << object->getLoaderIndentation() << "'" << child->Value() << "' is not a valid classname." << endl;
67	67	}
68	68	else
…	…
74	74	if (!identifier->isA(objectIdentifier_))
75	75	{
76		~~COUT(2) << object->getLoaderIndentation() << "Warning: '" << child->Value() << "' is not a '" << objectIdentifier_->getName() << "'." << std::~~endl;
	76	orxout(internal_warning, context::xml) << object->getLoaderIndentation() << "'" << child->Value() << "' is not a '" << objectIdentifier_->getName() << "'." << endl;
77	77	continue;
78	78	}
79	79	if (!identifier->isLoadable())
80	80	{
81		~~COUT(2) << object->getLoaderIndentation() << "Warning: '" << child->Value() << "' is not loadable." << std::~~endl;
	81	orxout(internal_warning, context::xml) << object->getLoaderIndentation() << "'" << child->Value() << "' is not loadable." << endl;
82	82	continue;
83	83	}
…	…
87	87	try
88	88	{
89		~~COUT(4) << object->getLoaderIndentation() << "fabricating " << child->Value() << "..." << std::~~endl;
	89	orxout(verbose, context::xml) << object->getLoaderIndentation() << "fabricating " << child->Value() << "..." << endl;
90	90
91	91	BaseObject* newObject = identifier->fabricate(object);
…	…
95	95	{
96	96	newObject->XMLPort(*child, XMLPort::LoadObject);
97		COUT(4) << object->getLoaderIndentation() << "assigning " << child->Value() << " (objectname " << newObject->getName() << ") to " << this->identifier_->getName() << " (objectname " << static_cast<BaseObject*>(object)->getName() << ')' << std::endl;
	97	orxout(verbose, context::xml) << object->getLoaderIndentation() << "assigning " << child->Value() << " (objectname " << newObject->getName() << ") to " << this->identifier_->getName() << " (objectname " << static_cast<BaseObject*>(object)->getName() << ')' << endl;
98	98	}
99	99	else
100	100	{
101		COUT(4) << object->getLoaderIndentation() << "assigning " << child->Value() << " (object not yet loaded) to " << this->identifier_->getName() << " (objectname " << static_cast<BaseObject*>(object)->getName() << ')' << std::endl;
	101	orxout(verbose, context::xml) << object->getLoaderIndentation() << "assigning " << child->Value() << " (object not yet loaded) to " << this->identifier_->getName() << " (objectname " << static_cast<BaseObject*>(object)->getName() << ')' << endl;
102	102	}
103
104		~~COUT(5) << object->getLoaderIndentation();~~
105	103
106	104	this->callLoadExecutor(object, newObject);
…	…
109	107	newObject->XMLPort(*child, XMLPort::LoadObject);
110	108
111		~~COUT(5) << object->getLoaderIndentation() << "...fabricated " << child->Value() << " (objectname " << newObject->getName() << ")." << std::~~endl;
	109	orxout(verbose, context::xml) << object->getLoaderIndentation() << "fabricated " << child->Value() << " (objectname " << newObject->getName() << ")." << endl;
112	110	}
113	111	catch (AbortLoadingException& ex)
114	112	{
115		~~COUT(1) << "An error occurred while loading object, abort loading..." << std::~~endl;
	113	orxout(internal_error, context::xml) << "An error occurred while loading object, abort loading..." << endl;
116	114	throw ex;
117	115	}
118	116	catch (...)
119	117	{
120		~~COUT(1) << "An error occurred while loading object:" << std::~~endl;
121		~~COUT(1) << Exception::handleMessage() << std::~~endl;
	118	orxout(internal_error, context::xml) << "An error occurred while loading object:" << endl;
	119	orxout(internal_error, context::xml) << Exception::handleMessage() << endl;
122	120	}
123	121	}
…	…
125	123	catch (ticpp::Exception& ex)
126	124	{
127		~~COUT(1) << std::~~endl;
128		COUT(1) << "An error occurred in XMLPort.h while loading a '" << objectIdentifier_->getName() << "' in '" << this->sectionname_ << "' of '" << this->identifier_->getName() << "' (objectname: " << object->getName() << ") in " << object->getFilename() << ':' << std::endl;
129		~~COUT(1) << ex.what() << std::~~endl;
	125	orxout(internal_error, context::xml) << endl;
	126	orxout(internal_error, context::xml) << "An error occurred in XMLPort.h while loading a '" << objectIdentifier_->getName() << "' in '" << this->sectionname_ << "' of '" << this->identifier_->getName() << "' (objectname: " << object->getName() << ") in " << object->getFilename() << ':' << endl;
	127	orxout(internal_error, context::xml) << ex.what() << endl;
130	128	}
131	129	}

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

-                      r7851
+                      r8858
 #include <tinyxml/ticpp.h>
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "util/Exception.h"
 #include "util/MultiType.h"
 …
                         if ((!attributeValue.empty()) || ((mode != XMLPort::ExpandObject) && this->loadexecutor_->allDefaultValuesSet()))
+                        {
                             COUT(5) << this->owner_->getLoaderIndentation() << "Loading parameter " << this->paramname_ << " in " << this->identifier_->getName() << " (objectname " << this->owner_->getName() << ")." << std::endl << this->owner_->getLoaderIndentation();
+                            orxout(verbose_more, context::xml) << this->owner_->getLoaderIndentation() << "Loading parameter " << this->paramname_ << " in " << this->identifier_->getName() << " (objectname " << this->owner_->getName() << ")." << endl;
                             int error;
                             this->loadexecutor_->parse(object, attributeValue, &error, ",");
 …
                     catch (ticpp::Exception& ex)
+                    {
                         COUT(1) << std::endl;
                         COUT(1) << "An error occurred in XMLPort.h while loading attribute '" << this->paramname_ << "' of '" << this->identifier_->getName() << "' (objectname: " << this->owner_->getName() << ") in " << this->owner_->getFilename() << ':' << std::endl;
                         COUT(1) << ex.what() << std::endl;
+                        orxout(internal_error, context::xml) << endl;
+                        orxout(internal_error, context::xml) << "An error occurred in XMLPort.h while loading attribute '" << this->paramname_ << "' of '" << this->identifier_->getName() << "' (objectname: " << this->owner_->getName() << ") in " << this->owner_->getFilename() << ':' << endl;
+                        orxout(internal_error, context::xml) << ex.what() << endl;
+                    }
+                }

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

-                      r8351
+                      r8858
             ArgumentCompletionList _groupsandcommands(const std::string& fragment, bool bOnlyShowHidden)
+            {
                 // note: this function returns only arguments that begin with "fragment", which would't be necessary for the
+                // note: this function returns only arguments that begin with "fragment", which wouldn't be necessary for the
                 //       auto-completion, but it's necessary to place the line-break "\n" between groups and commands
                 //       only if both groups AND commands are in the list.
 …
                 const std::map<std::string, std::map<std::string, ConsoleCommand*> >& commands = ConsoleCommand::getCommands();
                 for (std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = commands.begin(); it_group != commands.end(); ++it_group)
                     if (groupIsVisible(it_group->second, bOnlyShowHidden) && it_group->first != "" && (fragmentLC == "" || getLowercase(it_group->first).find_first_of(fragmentLC) == 0))
+                    if (groupIsVisible(it_group->second, bOnlyShowHidden) && it_group->first != "" && (fragmentLC == "" || getLowercase(it_group->first).find(fragmentLC) == 0))
                         groupList.push_back(ArgumentCompletionListElement(it_group->first, getLowercase(it_group->first)));
 …
                     // add the shortcuts
                     for (std::map<std::string, ConsoleCommand*>::const_iterator it_command = it_group->second.begin(); it_command != it_group->second.end(); ++it_command)
                         if (it_command->second->isActive() && it_command->second->hasAccess() && (!it_command->second->isHidden())^bOnlyShowHidden && (fragmentLC == "" || getLowercase(it_command->first).find_first_of(fragmentLC) == 0))
+                        if (it_command->second->isActive() && it_command->second->hasAccess() && (!it_command->second->isHidden())^bOnlyShowHidden && (fragmentLC == "" || getLowercase(it_command->first).find(fragmentLC) == 0))
                             groupList.push_back(ArgumentCompletionListElement(it_command->first, getLowercase(it_command->first)));
+                }

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

-                      r7401
+                      r8858
             if (!this->execCommand_)
                 *error = CommandExecutor::Error;
+                *error = CommandExecutor::Inexistent;
             else if (!this->execCommand_->isActive())
                 *error = CommandExecutor::Deactivated;
 …
             if (this->bEvaluatedArguments_)
+            {
                 COUT(6) << "CE_execute (evaluation): " << this->execCommand_->getName() << " with " << this->numberOfEvaluatedArguments_ << " arguments: " << this->arguments_[0] << ' ' << this->arguments_[1] << ' ' << this->arguments_[2] << ' ' << this->arguments_[3] << ' ' << this->arguments_[4] << std::endl;
+                orxout(verbose, context::commands) << "CE_execute (evaluation): " << this->execCommand_->getName() << " with " << this->numberOfEvaluatedArguments_ << " arguments: " << this->arguments_[0] << ' ' << this->arguments_[1] << ' ' << this->arguments_[2] << ' ' << this->arguments_[3] << ' ' << this->arguments_[4] << endl;
                 // pass as many arguments to the executor as were evaluated (thus the executor can still use additional default values)
 …
+        {
             if (bPrintError)
                 COUT(1) << "Error: Can't evaluate arguments, no console command assigned." << std::endl;
             return CommandExecutor::Error;
+                orxout(internal_error, context::commands) << "Can't evaluate arguments, no console command assigned." << endl;
+            return CommandExecutor::Inexistent;
+        }
 …
             this->bEvaluatedArguments_ = true;
         else if (bPrintError)
             COUT(1) << "Error: Can't evaluate arguments, not enough arguments given." << std::endl;
+            orxout(internal_error, context::commands) << "Can't evaluate arguments, not enough arguments given." << endl;
         return error;

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

-                      r7401
+                      r8858
         @return Returns the error-code (see @ref CommandExecutorErrorCodes "error codes")
     */
     /* static */ int CommandExecutor::execute(const std::string& command, bool useTcl)
+    /* static */ int CommandExecutor::execute(const std::string& command, bool useTcl, bool printErrors)
+    {
         int error;
         CommandExecutor::queryMT(command, &error, useTcl);
+        if (error && printErrors)
+            orxout(user_error) << "Can't execute \"" << command << "\", " << CommandExecutor::getErrorDescription(error) << ". (execute)" << endl;
         return error;
+    }
 …
     /* static */ MultiType CommandExecutor::queryMT(const std::string& command, int* error, bool useTcl)
+    {
+        MultiType result;
+        int error_internal;
         if (useTcl)
+        {
             // pass the command to tcl
             return TclBind::eval(command, error);
+            result = TclBind::eval(command, &error_internal);
+        }
         else
 …
             // query the command and return its return-value
+            return evaluation.query(error);
+        }
+            result = evaluation.query(&error_internal);
+        }
+        if (error)
+            *error = error_internal;
+        else if (error_internal)
+            orxout(user_error) << "Can't execute \"" << command << "\", " << CommandExecutor::getErrorDescription(error_internal) << ". (query)" << endl;
+        return result;
+    }
 …
     /**
+        @brief Returns a description of the error code.
+        @param error The error code
+    */
+    /* static */ std::string CommandExecutor::getErrorDescription(int error)
+    {
+        switch (error)
+        {
+            case CommandExecutor::Inexistent:  return "command doesn't exist";
+            case CommandExecutor::Incomplete:  return "not enough arguments given";
+            case CommandExecutor::Deactivated: return "command is not active";
+            case CommandExecutor::Denied:      return "access denied";
+            case CommandExecutor::Error:       return "an error occurred";
+            default: return "";
+        }
+    }
+    /**
         @brief Gets an evaluated command from the cache.
         @param command The command that should be looked up in the cache
 …
             if ((tokens.size() == 1 && ConsoleCommand::getCommand(tokens[0])) || (tokens.size() == 2 && ConsoleCommand::getCommand(tokens[0], tokens[1])))
+            {
                 COUT(1) << "Error: A command with name \"" << alias << "\" already exists." << std::endl;
+                orxout(user_error) << "A command with name \"" << alias << "\" already exists." << endl;
                 return;
+            }
 …
                 createConsoleCommand(tokens[0], tokens[1], executor);
             else
                 COUT(1) << "Error: \"" << alias << "\" is not a valid alias name (must have one or two words)." << std::endl;
+                orxout(user_error) << "\"" << alias << "\" is not a valid alias name (must have one or two words)." << endl;
+        }
         else
             COUT(1) << "Error: \"" << command << "\" is not a valid command (did you mean \"" << evaluation.getCommandSuggestion() << "\"?)." << std::endl;
+            orxout(user_error) << "\"" << command << "\" is not a valid command (did you mean \"" << evaluation.getCommandSuggestion() << "\"?)." << endl;
+    }
+}

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

-                      r7401
+                      r8858
 // tolua_end
         public:
             static int execute(const std::string& command, bool useTcl = true); // tolua_export
+            static int execute(const std::string& command, bool useTcl = true, bool printErrors = true); // tolua_export
             static MultiType queryMT(const std::string& command, int* error = 0, bool useTcl = true);
 …
             static const int Success = 0;       ///< Error code for "success" (or no error)
             static const int Error = 1;         ///< Error code if the command doesn't exist
+            static const int Inexistent = 1;    ///< Error code if the command doesn't exist
             static const int Incomplete = 2;    ///< Error code if the command needs more arguments
             static const int Deactivated = 3;   ///< Error code if the command is not active
             static const int Denied = 4;        ///< Error code if the command needs a different access level
+            static const int Error = 5;         ///< Error code if the command returned an error
+            static std::string getErrorDescription(int error);
             static MultiType unhide(const std::string& command);

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

-                      r8316
+                      r8858
                 if (!this->executor_->defaultValueSet(i))
+                {
                     COUT(2) << "Default value " << i << " is missing" << std::endl;
+                    orxout(internal_warning, context::commands) << "Default value " << i << " is missing" << endl;
                     return false;
+                }
 …
                 if (!executor->defaultValueSet(i))
+                {
                     COUT(2) << "Default value " << i << " is missing" << std::endl;
+                    orxout(internal_warning, context::commands) << "Default value " << i << " is missing" << endl;
                     return false;
+                }
 …
         else
+        {
             COUT(1) << "Error: Couldn't assign new executor to console command \"" << this->baseName_ << "\", headers don't match." << std::endl;
+            orxout(internal_error, context::commands) << "Couldn't assign new executor to console command \"" << this->baseName_ << "\", headers don't match." << endl;
             return false;
+        }
 …
         else
+        {
             COUT(1) << "Error: Couldn't assign new functor to console command \"" << this->baseName_ << "\", headers don't match." << std::endl;
+            orxout(internal_error, context::commands) << "Couldn't assign new functor to console command \"" << this->baseName_ << "\", headers don't match." << endl;
             return false;
+        }
 …
             this->pushFunction(new Executor(*this->executor_.get()));
         else
             COUT(1) << "Error: Couldn't push copy of executor in console command \"" << this->baseName_ << "\", no executor set." << std::endl;
+            orxout(internal_error, context::commands) << "Couldn't push copy of executor in console command \"" << this->baseName_ << "\", no executor set." << endl;
+    }
 …
+            }
             else if (object)
                 COUT(1) << "Error: Can't assign object to console command \"" << this->baseName_ << "\", no functor set." << std::endl;
+                orxout(internal_error, context::commands) << "Can't assign object to console command \"" << this->baseName_ << "\", no functor set." << endl;
+        }
         else if (object)
             COUT(1) << "Error: Can't assign object to console command \"" << this->baseName_ << "\", no executor set." << std::endl;
+            orxout(internal_error, context::commands) << "Can't assign object to console command \"" << this->baseName_ << "\", no executor set." << endl;
         return false;
 …
             this->executor_->setDefaultValues(arg1);
         else
             COUT(1) << "Error: Can't set default values in console command \"" << this->baseName_ << "\", no executor set." << std::endl;
+            orxout(internal_error, context::commands) << "Can't set default values in console command \"" << this->baseName_ << "\", no executor set." << endl;
         return *this;
 …
             this->executor_->setDefaultValues(arg1, arg2);
         else
             COUT(1) << "Error: Can't set default values in console command \"" << this->baseName_ << "\", no executor set." << std::endl;
+            orxout(internal_error, context::commands) << "Can't set default values in console command \"" << this->baseName_ << "\", no executor set." << endl;
         return *this;
 …
             this->executor_->setDefaultValues(arg1, arg2, arg3);
         else
             COUT(1) << "Error: Can't set default values in console command \"" << this->baseName_ << "\", no executor set." << std::endl;
+            orxout(internal_error, context::commands) << "Can't set default values in console command \"" << this->baseName_ << "\", no executor set." << endl;
         return *this;
 …
             this->executor_->setDefaultValues(arg1, arg2, arg3, arg4);
         else
             COUT(1) << "Error: Can't set default values in console command \"" << this->baseName_ << "\", no executor set." << std::endl;
+            orxout(internal_error, context::commands) << "Can't set default values in console command \"" << this->baseName_ << "\", no executor set." << endl;
         return *this;
 …
             this->executor_->setDefaultValues(arg1, arg2, arg3, arg4, arg5);
         else
             COUT(1) << "Error: Can't set default values in console command \"" << this->baseName_ << "\", no executor set." << std::endl;
+            orxout(internal_error, context::commands) << "Can't set default values in console command \"" << this->baseName_ << "\", no executor set." << endl;
         return *this;
 …
             this->executor_->setDefaultValue(index, arg);
         else
             COUT(1) << "Error: Can't set default values in console command \"" << this->baseName_ << "\", no executor set." << std::endl;
+            orxout(internal_error, context::commands) << "Can't set default values in console command \"" << this->baseName_ << "\", no executor set." << endl;
         return *this;
 …
             this->argumentCompleter_[index] = completer;
         else
             COUT(2) << "Warning: Couldn't add autocompletion-function for index " << index << " in console command \"" << this->baseName_ << "\": index out of bound." << std::endl;
+            orxout(internal_warning, context::commands) << "Couldn't add autocompletion-function for index " << index << " in console command \"" << this->baseName_ << "\": index out of bound." << endl;
         return *this;
 …
+        {
             if (group == "")
                 COUT(1) << "Error: Couldn't find console command with shortcut \"" << name << "\"" << std::endl;
+                orxout(internal_error, context::commands) << "Couldn't find console command with shortcut \"" << name << "\"" << endl;
             else
                 COUT(1) << "Error: Couldn't find console command with group \"" << group << "\" and name \"" << name << "\"" << std::endl;
+                orxout(internal_error, context::commands) << "Couldn't find console command with group \"" << group << "\" and name \"" << name << "\"" << endl;
+        }
         return 0;
 …
+        {
             if (group == "")
                 COUT(1) << "Error: Couldn't find console command with shortcut \"" << name << "\"" << std::endl;
+                orxout(internal_error, context::commands) << "Couldn't find console command with shortcut \"" << name << "\"" << endl;
             else
                 COUT(1) << "Error: Couldn't find console command with group \"" << group << "\" and name \"" << name << "\"" << std::endl;
+                orxout(internal_error, context::commands) << "Couldn't find console command with group \"" << group << "\" and name \"" << name << "\"" << endl;
+        }
         return 0;
 …
+        {
             if (group == "")
                 COUT(2) << "Warning: A console command with shortcut \"" << name << "\" already exists." << std::endl;
+                orxout(internal_warning, context::commands) << "A console command with shortcut \"" << name << "\" already exists." << endl;
             else
                 COUT(2) << "Warning: A console command with name \"" << name << "\" already exists in group \"" << group << "\"." << std::endl;
+                orxout(internal_warning, context::commands) << "A console command with name \"" << name << "\" already exists in group \"" << group << "\"." << endl;
+        }
         else

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

r8418	r8858
53	53	void myCoutFunction(const std::string& text) // Define a static function
54	54	{
55		~~COUT(0) << "Text: " << text << std::endl;~~ // Print the text to the console
	55	orxout() << "Text: " << text << endl; // Print the text to the console
56	56	}
57	57
…	…
125	125	void myOtherCoutFunction(const std::string& text) // Define a new static function
126	126	{
127		~~COUT(0) << "Uppercase: " << getUppercase(text) << std::endl;~~ // Print the text in uppercase to the console
	127	orxout() << "Uppercase: " << getUppercase(text) << endl; // Print the text in uppercase to the console
128	128	}
129	129

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

-                      r8079
+                      r8858
 #include <string>
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "util/ExprParser.h"
 #include "util/StringUtils.h"
 …
 namespace orxonox
+{
+    SetConsoleCommand("echo", echo);
+    SetConsoleCommand("orxout", orxout_level);
+    SetConsoleCommand("orxout_context", orxout_level_context);
+    SetConsoleCommand("log"    , log    );
+    SetConsoleCommand("error"  , error  ).hide();
+    SetConsoleCommand("warning", warning).hide();
+    SetConsoleCommand("status" , status ).hide();
+    SetConsoleCommand("info"   , info   ).hide();
+    SetConsoleCommand("debug"  , debug  ).hide();
 //    SetConsoleCommand("source", source).argumentCompleter(0, autocompletion::files());  // disabled because we use the implementation in Tcl
-    SetConsoleCommand("echo", echo);
-//    SetConsoleCommand("puts", puts);                                                    // disabled because we use the implementation in Tcl
 //    SetConsoleCommand("read", read).argumentCompleter(0, autocompletion::files());      // disabled because we use the implementation in Tcl
 //    SetConsoleCommand("append", append).argumentCompleter(0, autocompletion::files());  // disabled because we use the implementation in Tcl
 …
     /**
+        @brief Simply returns the arguments.
+    */
+    std::string echo(const std::string& text)
+    {
+        return text;
+    }
+    /**
+        @brief Builds a map that maps the levels of all output levels to their ID.
+    */
+    std::map<std::string, OutputLevel> getOutputLevelsMap()
+    {
+        std::map<std::string, OutputLevel> levels;
+        levels["message"]          = level::message;
+        levels["debug_output"]     = level::debug_output;
+        levels["user_error"]       = level::user_error;
+        levels["user_warning"]     = level::user_warning;
+        levels["user_status"]      = level::user_status;
+        levels["user_info"]        = level::user_info;
+        levels["internal_error"]   = level::internal_error;
+        levels["internal_warning"] = level::internal_warning;
+        levels["internal_status"]  = level::internal_status;
+        levels["internal_info"]    = level::internal_info;
+        levels["verbose"]          = level::verbose;
+        levels["verbose_more"]     = level::verbose_more;
+        levels["verbose_ultra"]    = level::verbose_ultra;
+        return levels;
+    }
+    /**
+        @brief Prints text to the console.
+        @param level_name The name of the output level
+    */
+    void orxout_level(const std::string& level_name, const std::string& text)
+    {
+        static std::map<std::string, OutputLevel> levels = getOutputLevelsMap();
+        OutputLevel level = level::debug_output;
+        std::map<std::string, OutputLevel>::iterator it = levels.find(level_name);
+        if (it != levels.end())
+            level = it->second;
+        else
+            orxout(internal_warning) << "'" << level_name << "' is not a valid output level" << endl;
+        orxout(level) << text << endl;
+    }
+    /**
+        @brief Prints text to the console.
+        @param level_name The name of the output level
+        @param context_name The name of the output context
+    */
+    void orxout_level_context(const std::string& level_name, const std::string& context_name, const std::string& text)
+    {
+        static std::map<std::string, OutputLevel> levels = getOutputLevelsMap();
+        OutputLevel level = level::debug_output;
+        std::map<std::string, OutputLevel>::iterator it = levels.find(level_name);
+        if (it != levels.end())
+            level = it->second;
+        else
+            orxout(internal_warning) << "'" << level_name << "' is not a valid output level" << endl;
+        OutputContextContainer context = registerContext(context_name);
+        orxout(level, context) << text << endl;
+    }
+    /// @brief Prints text to the console and the logfile.
+    void log(const std::string& text)
+    { orxout() << text << endl; }
+    /// @brief Prints output with error level.
+    void error(const std::string& text)
+    { orxout(user_error) << text << endl; }
+    /// @brief Prints output with warning level.
+    void warning(const std::string& text)
+    { orxout(user_warning) << text << endl; }
+    /// @brief Prints output with status level.
+    void status(const std::string& text)
+    { orxout(user_status) << text << endl; }
+    /// @brief Prints output with info level.
+    void info(const std::string& text)
+    { orxout(user_info) << text << endl; }
+    /// @brief Prints debug output with verbose level.
+    void debug(const std::string& text)
+    { orxout(verbose, context::tcl) << text << endl; }
+    /**
         @brief Reads the content of a file and executes the commands in it line by line.
     */
 …
         if (it != executingFiles.end())
+        {
             COUT(1) << "Error: Recurring source command in \"" << filename << "\". Stopped execution." << std::endl;
+            orxout(user_error) << "Recurring source command in \"" << filename << "\". Stopped execution." << endl;
             return;
+        }
 …
         if (!file.is_open())
+        {
             COUT(1) << "Error: Couldn't open file \"" << filename << "\"." << std::endl;
+            orxout(user_error) << "Couldn't open file \"" << filename << "\"." << endl;
             return;
+        }
 …
     /**
-        @brief Simply returns the arguments.
-    */
-    std::string echo(const std::string& text)
+    {
-        return text;
+    }
-    /**
-        @brief Writes text to the console, depending on the first argument with or without a line-break after it.
-    */
-    void puts(bool newline, const std::string& text)
+    {
-        if (newline)
+        {
-            COUT(0) << stripEnclosingBraces(text) << std::endl;
+        }
-        else
+        {
-            COUT(0) << stripEnclosingBraces(text);
+        }
+    }
-    /**
         @brief Writes text to a file.
     */
 …
         if (!file.is_open())
+        {
             COUT(1) << "Error: Couldn't write to file \"" << filename << "\"." << std::endl;
             return;
+        }
         file << text << std::endl;
+            orxout(user_error) << "Couldn't write to file \"" << filename << "\"." << endl;
+            return;
+        }
+        file << text << endl;
         file.close();
+    }
 …
         if (!file.is_open())
+        {
             COUT(1) << "Error: Couldn't append to file \"" << filename << "\"." << std::endl;
             return;
+        }
         file << text << std::endl;
+            orxout(user_error) << "Couldn't append to file \"" << filename << "\"." << endl;
+            return;
+        }
+        file << text << endl;
         file.close();
+    }
 …
         if (!file.is_open())
+        {
             COUT(1) << "Error: Couldn't read from file \"" << filename << "\"." << std::endl;
+            orxout(user_error) << "Couldn't read from file \"" << filename << "\"." << endl;
             return "";
+        }
 …
             if (expr.getResult() == 42.0)
+            {
                 COUT(3) << "Greetings from the restaurant at the end of the universe." << std::endl;
+                orxout(user_info) << "Greetings from the restaurant at the end of the universe." << endl;
+            }
             if (!expr.getRemains().empty())
+            {
                 COUT(2) << "Warning: Expression could not be parsed to the end! Remains: '" << expr.getRemains() << '\'' << std::endl;
+                orxout(user_warning) << "Expression could not be parsed to the end! Remains: '" << expr.getRemains() << '\'' << endl;
+            }
             return static_cast<float>(expr.getResult());
 …
         else
+        {
             COUT(1) << "Error: Cannot calculate expression: Parse error." << std::endl;
+            orxout(user_error) << "Cannot calculate expression: Parse error." << endl;
             return 0;
+        }

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

-                      r7401
+                      r8858
     _CoreExport void source(const std::string& filename);
     _CoreExport std::string echo(const std::string& text);
+    _CoreExport void puts(bool newline, const std::string& test);
+    _CoreExport void orxout_level(const std::string& level_name, const std::string& text);
+    _CoreExport void orxout_level_context(const std::string& level_name, const std::string& context_name, const std::string& text);
+    _CoreExport void log(const std::string& text);
+    _CoreExport void error(const std::string& text);
+    _CoreExport void warning(const std::string& text);
+    _CoreExport void status(const std::string& text);
+    _CoreExport void info(const std::string& text);
+    _CoreExport void debug(const std::string& text);
     _CoreExport void write(const std::string& filename, const std::string& text);

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

-                      r7401
+                      r8858
 #include "util/Convert.h"
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "util/StringUtils.h"
 #include "util/SubString.h"
 …
+        {
             if (bPrintError)
                 COUT(2) << "Warning: Can't call executor " << this->name_ << " through parser: Not enough arguments or default values given (input: " << arguments.join() << ")." << std::endl;
+                orxout(internal_warning) << "Can't call executor " << this->name_ << " through parser: Not enough arguments or default values given (input: " << arguments.join() << ")." << endl;
             return MT_Type::Null;
+        }
         COUT(5) << "Executor::parse: \"" << arguments.join(delimiter) << "\" -> " << argCount << " arguments: " << arg[0] << " / " << arg[1] << " / " << arg[2] << " / " << arg[3] << " / " << arg[4] << std::endl;
+        orxout(verbose, context::misc::executor) << "Executor::parse: \"" << arguments.join(delimiter) << "\" -> " << argCount << " arguments: " << arg[0] << " / " << arg[1] << " / " << arg[2] << " / " << arg[3] << " / " << arg[4] << endl;
         // execute the function with the evaluated arguments (the default values of the executor are also included in these arguments)

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

r7401	r8858
57	57	void myFunction(int a, int b) // declare a static function
58	58	{
59		~~COUT(0) << "The sum is " << (a + b) << std::endl;~~ // print the sum of a and b to the console
	59	orxout() << "The sum is " << (a + b) << endl; // print the sum of a and b to the console
60	60	}
61	61

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

-                      r8729
+                      r8858
 #include <typeinfo>
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "util/MultiType.h"
 #include "core/OrxonoxClass.h"
 …
                 else
+                {
                     COUT(1) << "Error: Can't execute FunctorMember, no object set." << std::endl;
+                    orxout(internal_error) << "Can't execute FunctorMember, no object set." << endl;
                     return MT_Type::Null;
+                }
 …
             // see Functor::setRawObjectPointer()
             inline void setRawObjectPointer(void*)
                 { COUT(2) << "Warning: Can't assign an object pointer to a static functor" << std::endl; }
+                { orxout(internal_warning) << "Can't assign an object pointer to a static functor" << endl; }
             // see Functor::getRawObjectPointer()
             inline void* getRawObjectPointer() const

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

-                      r8729
+                      r8858
 #include "util/Clock.h"
 #include "util/Math.h"
+#include "util/output/ConsoleWriter.h"
 #include "core/Game.h"
 #include "core/input/InputBuffer.h"
 …
     IOConsole::IOConsole()
         : shell_(new Shell("IOConsole", false))
+        : shell_(new Shell("Console", false))
         , buffer_(shell_->getInputBuffer())
         , cout_(std::cout.rdbuf())
 …
         // Disable standard std::cout logging
         OutputHandler::getInstance().disableCout();
+        ConsoleWriter::getInstance().disable();
         // Redirect std::cout to an ostringstream
         // (Other part is in the initialiser list)
 …
         std::cout.flush();
         if (!this->origCout_.str().empty())
             this->shell_->addOutput(this->origCout_.str(), Shell::None);
+            this->shell_->addOutput(this->origCout_.str(), Shell::Cout);
         // Erase input and status lines
         this->cout_ << "\033[1G\033[J";
 …
         std::cout.rdbuf(this->cout_.rdbuf());
         // Enable standard std::cout logging again
         OutputHandler::getInstance().enableCout();
+        ConsoleWriter::getInstance().enable();
+    }
 …
         if (!this->origCout_.str().empty())
+        {
             this->shell_->addOutput(this->origCout_.str(), Shell::None);
+            this->shell_->addOutput(this->origCout_.str(), Shell::Cout);
             this->origCout_.str("");
+        }
 …
         switch (type)
+        {
+        case Shell::Error:   this->cout_ << "\033[91m"; break;
+        case Shell::Warning: this->cout_ << "\033[93m"; break;
+        case Shell::Info:    this->cout_ << "\033[90m"; break;
+        case Shell::Debug:   this->cout_ << "\033[90m"; break;
+        case Shell::Verbose: this->cout_ << "\033[90m"; break;
+        case Shell::Ultra:   this->cout_ << "\033[90m"; break;
+        case Shell::Command: this->cout_ << "\033[36m"; break;
+        case Shell::Hint:    this->cout_ << "\033[33m"; break;
+        case Shell::TDebug:  this->cout_ << "\033[95m"; break;
+        default: break;
+            case Shell::Message:
+            case Shell::DebugOutput:     this->cout_ << "\033[0m"; break;
+            case Shell::UserError:       this->cout_ << "\033[91m"; break;
+            case Shell::UserWarning:     this->cout_ << "\033[93m"; break;
+            case Shell::UserStatus:      this->cout_ << "\033[92m"; break;
+            case Shell::UserInfo:        this->cout_ << "\033[96m"; break;
+            case Shell::InternalError:   this->cout_ << "\033[31m"; break;
+            case Shell::InternalWarning: this->cout_ << "\033[33m"; break;
+            case Shell::InternalStatus:  this->cout_ << "\033[32m"; break;
+            case Shell::InternalInfo:    this->cout_ << "\033[36m"; break;
+            case Shell::Verbose:         this->cout_ << "\033[94m"; break;
+            case Shell::VerboseMore:     this->cout_ << "\033[34m"; break;
+            case Shell::VerboseUltra:    this->cout_ << "\033[34m"; break;
+            case Shell::Command:         this->cout_ << "\033[95m"; break;
+            case Shell::Hint:            this->cout_ << "\033[35m"; break;
+            default:                     this->cout_ << "\033[37m"; break;
+        }
 …
     void IOConsole::executed()
+    {
         this->shell_->addOutput(this->promptString_ + this->shell_->getInput() + '\n', Shell::Command);
+        this->shell_->addOutput(this->promptString_ + this->shell_->getInput(), Shell::Command);
+    }
 …
+    {
         // Exit is not an option, just do nothing (Shell doesn't really exit too)
+    }
-    //! Called if only the last output-line has changed
-    void IOConsole::onlyLastLineChanged()
+    {
-        // Save cursor position and move it to the beginning of the first output line
-        this->cout_ << "\033[s\033[1A\033[1G";
-        // Erase the line
-        this->cout_ << "\033[K";
-        // Reprint the last output line
-        this->printOutputLine(this->shell_->getNewestLineIterator()->first, this->shell_->getNewestLineIterator()->second);
-        // Restore cursor
-        this->cout_ << "\033[u";
-        this->cout_.flush();
+    }

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

r7401	r8858
66	66	// Methods from ShellListener
67	67	void linesChanged();
68		~~void onlyLastLineChanged();~~
69	68	void lineAdded();
70	69	void inputChanged();

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

-                      r8729
+                      r8858
 #include "util/Clock.h"
 #include "util/Math.h"
+#include "util/output/ConsoleWriter.h"
 #include "core/Game.h"
 #include "core/input/InputBuffer.h"
 …
     //! Redirects std::cout, creates the corresponding Shell and changes the terminal mode
     IOConsole::IOConsole()
         : shell_(new Shell("IOConsole", false))
+        : shell_(new Shell("Console", false))
         , buffer_(shell_->getInputBuffer())
         , cout_(std::cout.rdbuf())
 …
+    {
         // Disable standard this->cout_ logging
         OutputHandler::getInstance().disableCout();
+        ConsoleWriter::getInstance().disable();
         // Redirect std::cout to an ostringstream
         // (Other part is in the initialiser list)
 …
         std::cout.flush();
         if (!this->origCout_.str().empty())
             this->shell_->addOutput(this->origCout_.str(), Shell::None);
+            this->shell_->addOutput(this->origCout_.str(), Shell::Cout);
         this->shell_->unregisterListener(this);
 …
         std::cout.rdbuf(this->cout_.rdbuf());
         // Enable standard this->cout_ logging again
         OutputHandler::getInstance().enableCout();
+        ConsoleWriter::getInstance().enable();
         resetTerminalMode();
 …
         if (!this->origCout_.str().empty())
+        {
             this->shell_->addOutput(this->origCout_.str(), Shell::None);
+            this->shell_->addOutput(this->origCout_.str(), Shell::Cout);
             this->origCout_.str("");
+        }
 …
         switch (type)
+        {
+        case Shell::Error:   colour = FOREGROUND_INTENSITY                    | FOREGROUND_RED; break;
+        case Shell::Warning: colour = FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED; break;
+        case Shell::Info:
+        case Shell::Debug:
+        case Shell::Verbose:
+        case Shell::Ultra:   colour = FOREGROUND_INTENSITY                                     ; break;
+        case Shell::Command: colour =                        FOREGROUND_GREEN                  | FOREGROUND_BLUE; break;
+        case Shell::Hint:    colour =                        FOREGROUND_GREEN | FOREGROUND_RED                  ; break;
+        case Shell::TDebug:  colour = FOREGROUND_INTENSITY                    | FOREGROUND_RED | FOREGROUND_BLUE; break;
+        default:             colour =                        FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE; break;
+            case Shell::Message:
+            case Shell::DebugOutput:     colour = FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE; break;
+            case Shell::UserError:       colour = FOREGROUND_INTENSITY | FOREGROUND_RED | 0                | 0              ; break;
+            case Shell::UserWarning:     colour = FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | 0              ; break;
+            case Shell::UserStatus:      colour = FOREGROUND_INTENSITY | 0              | FOREGROUND_GREEN | 0              ; break;
+            case Shell::UserInfo:        colour = FOREGROUND_INTENSITY | 0              | FOREGROUND_GREEN | FOREGROUND_BLUE; break;
+            case Shell::InternalError:   colour = 0                    | FOREGROUND_RED | 0                | 0              ; break;
+            case Shell::InternalWarning: colour = 0                    | FOREGROUND_RED | FOREGROUND_GREEN | 0              ; break;
+            case Shell::InternalStatus:  colour = 0                    | 0              | FOREGROUND_GREEN | 0              ; break;
+            case Shell::InternalInfo:    colour = 0                    | 0              | FOREGROUND_GREEN | FOREGROUND_BLUE; break;
+            case Shell::Verbose:         colour = FOREGROUND_INTENSITY | 0              | 0                | FOREGROUND_BLUE; break;
+            case Shell::VerboseMore:     colour = FOREGROUND_INTENSITY | 0              | 0                | FOREGROUND_BLUE; break;
+            case Shell::VerboseUltra:    colour = FOREGROUND_INTENSITY | 0              | 0                | FOREGROUND_BLUE; break;
+            case Shell::Command:         colour = FOREGROUND_INTENSITY | FOREGROUND_RED | 0                | FOREGROUND_BLUE; break;
+            case Shell::Hint:            colour = 0                    | FOREGROUND_RED | 0                | FOREGROUND_BLUE; break;
+            default:                     colour = 0                    | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE; break;
+        }
 …
             || !SetConsoleMode(this->stdInHandle_, 0))
+        {
             COUT(1) << "Error: Could not set Windows console settings" << std::endl;
+            orxout(user_error) << "Could not set Windows console settings" << endl;
             return;
+        }
 …
     void IOConsole::executed()
+    {
         this->shell_->addOutput(this->promptString_ + this->shell_->getInput() + '\n', Shell::Command);
+        this->shell_->addOutput(this->promptString_ + this->shell_->getInput(), Shell::Command);
+    }
 …
+    }
-    //! Called if only the last output-line has changed
-    void IOConsole::onlyLastLineChanged()
+    {
-        int newLineHeight = 1 + this->shell_->getNewestLineIterator()->first.size() / this->terminalWidth_;
-        // Compute the number of new lines needed
-        int newLines = newLineHeight - this->lastOutputLineHeight_;
-        this->lastOutputLineHeight_ = newLineHeight;
-        // Scroll console if necessary
-        if (newLines > 0) // newLines < 0 is assumed impossible
-            this->createNewOutputLines(newLines);
-        Shell::LineList::const_iterator it = this->shell_->getNewestLineIterator();
-        this->printOutputLine(it->first, it->second, makeCOORD(0, this->inputLineRow_ - newLineHeight));
+    }
     //! Called if a new output line was added
     void IOConsole::lineAdded()

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

r8729	r8858
68	68	// Methods from ShellListener
69	69	void linesChanged();
70		~~void onlyLastLineChanged();~~
71	70	void lineAdded();
72	71	void inputChanged();

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

r7401	r8858
85	85	}
86	86	catch (Tcl::tcl_error const &e)
87		{ ~~COUT(1) << "Tcl (IRC) error: " << e.what()~~; }
	87	{ orxout(user_error, context::tcl) << "Tcl (IRC) error: " << e.what() << endl; }
88	88
89	89	this->nickname_ = "orx" + multi_cast<std::string>(static_cast<unsigned int>(rand()));
…	…
100	100	{
101	101	IRC::getInstance().initialize();
102		~~COUT(1) << "Error: IRC client wasn't yet initialized, please try again." << std::~~endl;
	102	orxout(user_error) << "IRC client wasn't yet initialized, please try again." << endl;
103	103	return false;
104	104	}
…	…
110	110	}
111	111	catch (Tcl::tcl_error const &e)
112		{ ~~COUT(1) << "Tcl (IRC) error: " << e.what()~~; }
	112	{ orxout(user_error, context::tcl) << "Tcl (IRC) error: " << e.what() << endl; }
113	113
114	114	return false;
…	…
139	139	void IRC::tcl_say(Tcl::object const &channel, Tcl::object const &nick, Tcl::object const &args)
140	140	{
141		~~COUT(0) << "IRC> " << nick.get() << ": " << stripEnclosingBraces(args.get()) << std::~~endl;
	141	orxout(message) << "IRC> " << nick.get() << ": " << stripEnclosingBraces(args.get()) << endl;
142	142	}
143	143
…	…
145	145	void IRC::tcl_privmsg(Tcl::object const &query, Tcl::object const &nick, Tcl::object const &args)
146	146	{
147		~~COUT(0) << "IRC (" << query.get() << ")> " << nick.get() << ": " << stripEnclosingBraces(args.get()) << std::~~endl;
	147	orxout(message) << "IRC (" << query.get() << ")> " << nick.get() << ": " << stripEnclosingBraces(args.get()) << endl;
148	148	}
149	149
…	…
151	151	void IRC::tcl_action(Tcl::object const &channel, Tcl::object const &nick, Tcl::object const &args)
152	152	{
153		~~COUT(0) << "IRC> * " << nick.get() << ' ' << stripEnclosingBraces(args.get()) << std::~~endl;
	153	orxout(message) << "IRC> * " << nick.get() << ' ' << stripEnclosingBraces(args.get()) << endl;
154	154	}
155	155
…	…
157	157	void IRC::tcl_info(Tcl::object const &channel, Tcl::object const &args)
158	158	{
159		~~COUT(0) << "IRC> --> " << stripEnclosingBraces(args.get()) << std::~~endl;
	159	orxout(message) << "IRC> --> " << stripEnclosingBraces(args.get()) << endl;
160	160	}
161	161	}

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

-                      r8729
+                      r8858
 #include "util/Math.h"
-#include "util/OutputHandler.h"
 #include "util/StringUtils.h"
 #include "util/SubString.h"
+#include "util/output/OutputManager.h"
+#include "util/output/MemoryWriter.h"
 #include "core/CoreIncludes.h"
 #include "core/ConfigFileManager.h"
 …
 #include "core/input/InputBuffer.h"
 #include "CommandExecutor.h"
-#include "ConsoleCommand.h"
 namespace orxonox
+{
-    SetConsoleCommand("log",     OutputHandler::log    );
-    SetConsoleCommand("error",   OutputHandler::error  ).hide();
-    SetConsoleCommand("warning", OutputHandler::warning).hide();
-    SetConsoleCommand("info",    OutputHandler::info   ).hide();
-    SetConsoleCommand("debug",   OutputHandler::debug  ).hide();
     unsigned int Shell::cacheSize_s;
+    /**
+        @brief Constructor: Initializes the values and registers itself at OutputHandler.
+    namespace DefaultLogLevel
+    {
+        const OutputLevel Dev  = level::internal_warning;
+        const OutputLevel User = level::user_info;
+    }
+    /**
+        @brief Constructor: Initializes the values.
         @param consoleName The name of the shell - used to define the name of the soft-debug-level config-value
         @param bScrollable If true, the user is allowed to scroll through the output-lines
     */
     Shell::Shell(const std::string& consoleName, bool bScrollable)
         : OutputListener(consoleName)
+        : BaseWriter(consoleName, false)
         , inputBuffer_(new InputBuffer())
-        , consoleName_(consoleName)
         , bScrollable_(bScrollable)
+    {
         RegisterRootObject(Shell);
+        OutputManager::getInstance().registerListener(this);
         this->scrollPosition_ = 0;
 …
         this->historyPosition_ = 0;
         this->historyOffset_ = 0;
-        this->bFinishedLastLine_ = true;
         this->clearOutput();
 …
         ConfigFileManager::getInstance().setFilename(ConfigFileType::CommandHistory, "commandHistory.ini");
+        // Use a stringstream object to buffer the output
+        this->outputStream_ = &this->outputBuffer_;
+        // Choose the default level according to the path Orxonox was started (build directory or not)
+        OutputLevel defaultDebugLevel = (PathConfig::buildDirectoryRun() ? DefaultLogLevel::Dev : DefaultLogLevel::User);
+        this->setLevelMax(defaultDebugLevel);
         this->setConfigValues();
         // Get the previous output and add it to the Shell
+        OutputHandler::OutputVector::const_iterator it = OutputHandler::getInstance().getOutput().begin();
+        for (;it != OutputHandler::getInstance().getOutput().end(); ++it)
+        {
+            if (it->first <= debugLevel_)
+            {
+                this->outputBuffer_ << it->second;
+                this->outputChanged(it->first);
+            }
+        }
+        // Register the shell as output listener
+        OutputHandler::getInstance().registerOutputListener(this);
+        OutputHandler::getInstance().setSoftDebugLevel(consoleName_, debugLevel_);
+    }
+    /**
+        @brief Destructor: Unregisters the shell from OutputHandler.
+        MemoryWriter::getInstance().resendOutput(this);
+    }
+    /**
+        @brief Destructor
     */
     Shell::~Shell()
+    {
-        OutputHandler::getInstance().unregisterOutputListener(this);
         this->inputBuffer_->destroy();
+    }
+    namespace DefaultLogLevel
+    {
+        const OutputLevel::Value Dev  = OutputLevel::Info;
+        const OutputLevel::Value User = OutputLevel::Error;
+        OutputManager::getInstance().unregisterListener(this);
+    }
 …
         SetConfigValue(cacheSize_s, 32);
+        // Choose the default level according to the path Orxonox was started (build directory or not)
+        OutputLevel::Value defaultDebugLevel = (PathConfig::buildDirectoryRun() ? DefaultLogLevel::Dev : DefaultLogLevel::User);
+        SetConfigValueExternal(debugLevel_, "OutputHandler", "debugLevel" + consoleName_, defaultDebugLevel)
+            .description("The maximum level of debug output shown in the " + consoleName_);
+        OutputHandler::getInstance().setSoftDebugLevel(consoleName_, debugLevel_);
+        SetConfigValueExternal(this->configurableMaxLevel_,
+                               this->getConfigurableSectionName(),
+                               this->getConfigurableMaxLevelName(),
+                               this->configurableMaxLevel_)
+            .description("The maximum level of output shown in the " + this->getName())
+            .callback(static_cast<BaseWriter*>(this), &BaseWriter::changedConfigurableLevel);
+        SetConfigValueExternal(this->configurableAdditionalContextsMaxLevel_,
+                               this->getConfigurableSectionName(),
+                               this->getConfigurableAdditionalContextsMaxLevelName(),
+                               this->configurableAdditionalContextsMaxLevel_)
+            .description("The maximum level of output shown in the " + this->getName() + " for additional contexts")
+            .callback(static_cast<BaseWriter*>(this), &BaseWriter::changedConfigurableAdditionalContextsLevel);
+        SetConfigValueExternal(this->configurableAdditionalContexts_,
+                               this->getConfigurableSectionName(),
+                               this->getConfigurableAdditionalContextsName(),
+                               this->configurableAdditionalContexts_)
+            .description("Additional output contexts shown in the " + this->getName())
+            .callback(static_cast<BaseWriter*>(this), &BaseWriter::changedConfigurableAdditionalContexts);
+    }
 …
         if (isNormal)
+        {
             ModifyConfigValueExternal(debugLevel_, "debugLevel" + consoleName_, update);
+            ModifyConfigValueExternal(this->configurableMaxLevel_, this->getConfigurableMaxLevelName(), update);
+        }
         else
+        {
             OutputLevel::Value level = (value ? DefaultLogLevel::Dev : DefaultLogLevel::User);
             ModifyConfigValueExternal(debugLevel_, "debugLevel" + consoleName_, tset, level);
+            OutputLevel level = (value ? DefaultLogLevel::Dev : DefaultLogLevel::User);
+            ModifyConfigValueExternal(this->configurableMaxLevel_, this->getConfigurableMaxLevelName(), tset, level);
+        }
+    }
 …
     /**
         @brief Sends output to the internal output buffer.
+        @brief Adds multiple lines to the internal output buffer.
     */
     void Shell::addOutput(const std::string& text, LineType type)
+    {
+        this->outputBuffer_ << text;
+        this->outputChanged(type);
+        std::vector<std::string> lines;
+        vectorize(text, '\n', &lines);
+        for (size_t i = 0; i < lines.size(); ++i)
+            this->addLine(lines[i], type);
+    }
+    /**
+        @brief Adds a line to the internal output buffer.
+    */
+    void Shell::addLine(const std::string& line, LineType type)
+    {
+        // yes it was - push the new line to the list
+        this->outputLines_.push_front(std::make_pair(line, static_cast<LineType>(type)));
+        // adjust the scroll position if needed
+        if (this->scrollPosition_)
+            this->scrollPosition_++;
+        else
+            this->scrollIterator_ = this->outputLines_.begin();
+        if (!this->scrollPosition_)
+            this->updateListeners<&ShellListener::lineAdded>();
+    }
 …
         this->scrollPosition_ = 0;
-        this->bFinishedLastLine_ = true;
         this->updateListeners<&ShellListener::linesChanged>();
+    }
+    /**
+        @brief Inherited from BaseWriter (LogListener), called if a new line of output was sent.
+    */
+    void Shell::printLine(const std::string& line, OutputLevel level)
+    {
+        this->addLine(line, static_cast<LineType>(level));
+    }
 …
     /**
-        @brief Called by OutputHandler or internally whenever output was sent to the output buffer. Reads from the buffer and writes the new output-lines to the list.
-    */
-    void Shell::outputChanged(int lineType)
+    {
-        bool newline = false;
-        do
+        {
-            // get the first line from the buffer
-            std::string output;
-            std::getline(this->outputBuffer_, output);
-            // check the state of the buffer
-            bool eof = this->outputBuffer_.eof();
-            bool fail = this->outputBuffer_.fail();
-            if (eof)
-                this->outputBuffer_.flush(); // check if more output was received in the meantime
-            if (eof || fail)
-                this->outputBuffer_.clear(); // clear the error flags
-            // the line is terminated with a line-break if neither an error occurred nor the end of the file was reached
-            newline = (!eof && !fail);
-            // no output retrieved - break the loop
-            if (!newline && output.empty())
-                break;
-            // check if the last line was terminated with a line-break
-            if (this->bFinishedLastLine_)
+            {
-                // yes it was - push the new line to the list
-                this->outputLines_.push_front(std::make_pair(output, static_cast<LineType>(lineType)));
-                // adjust the scroll position if needed
-                if (this->scrollPosition_)
-                    this->scrollPosition_++;
-                else
-                    this->scrollIterator_ = this->outputLines_.begin();
-                if (!this->scrollPosition_)
-                    this->updateListeners<&ShellListener::lineAdded>();
+            }
-            else
+            {
-                // no it wasn't - add the new output to the last line
-                this->outputLines_.front().first += output;
-                this->updateListeners<&ShellListener::onlyLastLineChanged>();
+            }
-            // remember if the last line was terminated with a line-break
-            this->bFinishedLastLine_ = newline;
-        } while (newline); // loop as long as more lines are in the buffer
+    }
-    /**
         @brief Clears the text in the input buffer.
     */
 …
         const std::string& result = CommandExecutor::query(this->inputBuffer_->get(), &error);
         if (error)
+        {
+            switch (error)
+            {
+                case CommandExecutor::Error:       this->outputBuffer_ << "Error: Can't execute \"" << this->inputBuffer_->get() << "\", command doesn't exist. (S)" << std::endl; break;
+                case CommandExecutor::Incomplete:  this->outputBuffer_ << "Error: Can't execute \"" << this->inputBuffer_->get() << "\", not enough arguments given. (S)" << std::endl; break;
+                case CommandExecutor::Deactivated: this->outputBuffer_ << "Error: Can't execute \"" << this->inputBuffer_->get() << "\", command is not active. (S)" << std::endl; break;
+                case CommandExecutor::Denied:      this->outputBuffer_ << "Error: Can't execute \"" << this->inputBuffer_->get() << "\", access denied. (S)" << std::endl; break;
+            }
+            this->outputChanged(Error);
+        }
+            this->addOutput("Error: Can't execute \"" + this->inputBuffer_->get() + "\", " + CommandExecutor::getErrorDescription(error) + ". (Shell)", UserError);
         else if (result != "")
+        {
+            this->outputBuffer_ << result << std::endl;
+            this->outputChanged(Command);
+        }
+            this->addOutput(result, Result);
         this->clearInput();
 …
+    {
         this->inputBuffer_->set(CommandExecutor::evaluate(this->inputBuffer_->get()).complete());
+        this->outputBuffer_ << CommandExecutor::evaluate(this->inputBuffer_->get()).hint() << std::endl;
+        this->outputChanged(Hint);
+        this->addOutput(CommandExecutor::evaluate(this->inputBuffer_->get()).hint(), Hint);
         this->inputChanged();

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

-                      r8729
+                      r8858
 #include <vector>
 #include "util/OutputHandler.h"
+#include "util/output/BaseWriter.h"
 #include "core/Core.h"
 #include "core/OrxonoxClass.h"
 …
         private:
             virtual void linesChanged() {}          ///< Called if all output-lines have changed
-            virtual void onlyLastLineChanged() {}   ///< Called if only the last output-line has changed
             virtual void lineAdded() {}             ///< Called if a new line was added to the output
             virtual void inputChanged() {}          ///< Called if the input has changed
 …
         @brief The Shell is the logical component of the console that displays output to the user and allows him to enter commands.
         The Shell gathers output sent from OutputHandler by inheriting from OutputListener.
+        The Shell gathers output sent from OutputManager by inheriting from BaseWriter.
         The output-lines are stored in the shell, so they can be displayed in a graphical
         console. Additionally the Shell has an InputBuffer which is needed by the user to
 …
         Different graphical consoles build upon a Shell, for example InGameConsole and IOConsole.
     */
     class _CoreExport Shell : public OutputListener, public DevModeListener
+    class _CoreExport Shell : public BaseWriter, public DevModeListener
+    {
         public:
 …
             enum LineType
+            {
+                TDebug  = OutputLevel::TDebug,
+                None    = OutputLevel::None,
+                Warning = OutputLevel::Warning,
+                Error   = OutputLevel::Error,
+                Info    = OutputLevel::Info,
+                Debug   = OutputLevel::Debug,
+                Verbose = OutputLevel::Verbose,
+                Ultra   = OutputLevel::Ultra,
+                DebugOutput     = debug_output,
+                Message         = message,
+                UserError       = user_error,
+                UserWarning     = user_warning,
+                UserStatus      = user_status,
+                UserInfo        = user_info,
+                InternalError   = internal_error,
+                InternalWarning = internal_warning,
+                InternalStatus  = internal_status,
+                InternalInfo    = internal_info,
+                Verbose         = verbose,
+                VerboseMore     = verbose_more,
+                VerboseUltra    = verbose_ultra,
+                Cout,
                 Input,
                 Command,
+                Result,
                 Hint
             };
 …
             LineList::const_iterator getEndIterator() const;
+            void addOutput(const std::string& text, LineType type = None);
+            void addOutput(const std::string& text, LineType type = DebugOutput);
+            void addLine(const std::string& line, LineType type = DebugOutput);
             void clearOutput();
 …
             const std::string& getFromHistory() const;
             void clearInput();
             // OutputListener
             void outputChanged(int level);
+            // BaseWriter
+            virtual void printLine(const std::string& line, OutputLevel level);
             void configureInputBuffer();
 …
             std::list<ShellListener*> listeners_;           ///< The registered shell listeners
             InputBuffer*              inputBuffer_;         ///< The input buffer that is needed by the user to enter text
-            std::stringstream         outputBuffer_;        ///< The output buffer that is used to retrieve lines of output from OutputListener
-            bool                      bFinishedLastLine_;   ///< Stores if the most recent output-line was terminated with a line-break or if more output is expected for this line
             LineList                  outputLines_;         ///< A list of all output-lines that were displayed in the shell so far
             LineList::const_iterator  scrollIterator_;      ///< An iterator to an entry of the list of output-lines, changes if the user scrolls through the output in the shell
             unsigned int              scrollPosition_;      ///< The number of the line that is currently being referenced by scrollIterator_
             unsigned int              historyPosition_;     ///< If the user scrolls through the history of entered commands (stored in commandHistory_), this contains the currently viewed history entry
-            const std::string         consoleName_;         ///< The name of this shell - used to define the name of the soft-debug-level config-value
             const bool                bScrollable_;         ///< If true, the user can scroll through the output-lines
 …
             unsigned int              historyOffset_;       ///< The command history is a circular buffer, this variable defines the current write-offset
             std::vector<std::string>  commandHistory_;      ///< The history of commands that were entered by the user
-            int                       debugLevel_;          //!< The maximum level of output that is displayed in the shell (will be passed to OutputListener to filter output)
             static unsigned int       cacheSize_s;          ///< The maximum cache size of the CommandExecutor - this is stored here for better readability of the config file and because CommandExecutor is no OrxonoxClass
     };

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

-                      r8366
+                      r8858
 #include "SpecialConfig.h"
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "util/Exception.h"
 #include "util/StringUtils.h"
 …
+            }
             catch (Tcl::tcl_error const &e)
             {   COUT(1) << "Tcl error while creating Tcl-interpreter: " << e.what() << std::endl;   }
+            {   orxout(internal_error, context::tcl) << "Tcl error while creating Tcl-interpreter: " << e.what() << endl;   }
+        }
+    }
 …
+        }
         catch (Tcl::tcl_error const &e)
+        {   COUT(1) << "Tcl error while creating Tcl-interpreter: " << e.what() << std::endl; COUT(1) << "Error: Tcl isn't properly initialized. Orxonox might possibly not work like that." << std::endl;   }
+        {
+            orxout(internal_error, context::tcl) << "Tcl error while creating Tcl-interpreter: " << e.what() << endl;
+            orxout(user_error, context::tcl) << "Tcl isn't properly initialized. Orxonox might possibly not work like that." << endl;
+        }
         return interpreter;
 …
     std::string TclBind::tcl_query(Tcl::object const &args)
+    {
         COUT(4) << "Tcl_query: " << args.get() << std::endl;
+        orxout(verbose, context::commands) << "Tcl_query: " << args.get() << endl;
         return TclBind::tcl_helper(args, true);
+    }
 …
     void TclBind::tcl_execute(Tcl::object const &args)
+    {
         COUT(4) << "Tcl_execute: " << args.get() << std::endl;
+        orxout(verbose, context::commands) << "Tcl_execute: " << args.get() << endl;
         TclBind::tcl_helper(args, false);
+    }
 …
             error = evaluation.execute();
+        switch (error)
+        {
+            case CommandExecutor::Error:       COUT(1) << "Error: Can't execute command \"" << command << "\", command doesn't exist. (B)" << std::endl; break;
+            case CommandExecutor::Incomplete:  COUT(1) << "Error: Can't execute command \"" << command << "\", not enough arguments given. (B)" << std::endl; break;
+            case CommandExecutor::Deactivated: COUT(1) << "Error: Can't execute command \"" << command << "\", command is not active. (B)" << std::endl; break;
+            case CommandExecutor::Denied:      COUT(1) << "Error: Can't execute command \"" << command << "\", access denied. (B)" << std::endl; break;
+        }
+        if (error == CommandExecutor::Error)
+            COUT(3) << "Did you mean \"" << evaluation.getCommandSuggestion() << "\"?" << std::endl;
+        if (error)
+        {
+            orxout(user_error) << "Can't execute command \"" << command << "\", " + CommandExecutor::getErrorDescription(error) + ". (TclBind)" << endl;
+            if (error == CommandExecutor::Inexistent)
+                orxout(user_info) << "Did you mean \"" << evaluation.getCommandSuggestion() << "\"?" << endl;
+        }
         return result;
 …
+            }
             catch (Tcl::tcl_error const &e)
             {   COUT(1) << "Tcl error: " << e.what() << std::endl;   }
+            {   orxout(user_error, context::tcl) << "Tcl error: " << e.what() << endl;   }
+        }
 …
     void TclBind::bgerror(const std::string& error)
+    {
         COUT(1) << "Tcl background error: " << stripEnclosingBraces(error) << std::endl;
+        orxout(user_error, context::tcl) << "Tcl background error: " << stripEnclosingBraces(error) << endl;
+    }
 …
+        }
         catch (Tcl::tcl_error const &e)
         {   COUT(1) << "Tcl error: " << e.what() << std::endl;   }
+        {   orxout(user_error, context::tcl) << "Tcl error: " << e.what() << endl;   }
         if (error)

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

-                      r8351
+                      r8858
         TclThreadManager::getInstance().numInterpreterBundles_++;
         TclThreadManager::createWithId(TclThreadManager::getInstance().numInterpreterBundles_);
         COUT(0) << "Created new Tcl-interpreter with ID " << TclThreadManager::getInstance().numInterpreterBundles_ << std::endl;
+        orxout(user_info) << "Created new Tcl-interpreter with ID " << TclThreadManager::getInstance().numInterpreterBundles_ << endl;
         return TclThreadManager::getInstance().numInterpreterBundles_;
+    }
 …
+        }
         catch (const Tcl::tcl_error& e)
+        {   bundle->interpreter_ = 0; COUT(1) << "Tcl error while creating Tcl-interpreter (" << id_string << "): " << e.what() << std::endl;   }
+        {
+            bundle->interpreter_ = 0;
+            orxout(user_error, context::tcl) << "Tcl error while creating Tcl-interpreter (" << id_string << "): " << e.what() << endl;
+        }
+    }
 …
+            {
                 // This query would lead to a deadlock - return with an error
                 TclThreadManager::error("Error: Circular query (" + this->dumpList(source_bundle->queriers_.getList()) + ' ' + multi_cast<std::string>(source_bundle->id_) \
+                TclThreadManager::error("Circular query (" + this->dumpList(source_bundle->queriers_.getList()) + ' ' + multi_cast<std::string>(source_bundle->id_) \
                             + " -> " + multi_cast<std::string>(target_bundle->id_) \
                             + "), couldn't query Tcl-interpreter with ID " + multi_cast<std::string>(target_bundle->id_) \
 …
                         int error;
                         output = CommandExecutor::query(command, &error, false);
+                        switch (error)
+                        {
+                            case CommandExecutor::Error:       TclThreadManager::error("Error: Can't execute command \"" + command + "\", command doesn't exist. (T)"); break;
+                            case CommandExecutor::Incomplete:  TclThreadManager::error("Error: Can't execute command \"" + command + "\", not enough arguments given. (T)"); break;
+                            case CommandExecutor::Deactivated: TclThreadManager::error("Error: Can't execute command \"" + command + "\", command is not active. (T)"); break;
+                            case CommandExecutor::Denied:      TclThreadManager::error("Error: Can't execute command \"" + command + "\", access denied. (T)"); break;
+                        }
+                        if (error)
+                            TclThreadManager::error("Can't execute command \"" + command + "\", " + CommandExecutor::getErrorDescription(error) + ". (TclThreadManager)");
+                    }
                     else
 …
                     // This happens if the main thread tries to query a busy interpreter
                     // To avoid a lock of the main thread, we simply don't proceed with the query in this case
                     TclThreadManager::error("Error: Couldn't query Tcl-interpreter with ID " + multi_cast<std::string>(target_bundle->id_) + ", interpreter is busy right now.");
+                    TclThreadManager::error("Couldn't query Tcl-interpreter with ID " + multi_cast<std::string>(target_bundle->id_) + ", interpreter is busy right now.");
+                }
+            }
 …
         else
+        {
             TclThreadManager::error("Error: No Tcl-interpreter with ID " + multi_cast<std::string>(id) + " existing.");
+            TclThreadManager::error("No Tcl-interpreter with ID " + multi_cast<std::string>(id) + " existing.");
             return 0;
+        }

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

r7891	r8858
38	38	#include "util/SubString.h"
39	39	#include "util/StringUtils.h"
40		#include "util/~~Debug~~.h"
	40	#include "util/Output.h"
41	41	#include "core/command/ConsoleCommand.h"
42	42	#include "core/command/CommandEvaluation.h"
…	…
255	255	if (serious)
256	256	{
257		~~COUT(2~~) << "Error while parsing binding for button/axis " << this->name_ << ". "
258		<< message << ~~std::~~endl;
	257	orxout(internal_error, context::input) << "Error while parsing binding for button/axis " << this->name_ << ". "
	258	<< message << endl;
259	259	}
260	260	else
261	261	{
262		~~COUT(3~~) << "Warning while parsing binding for button/axis " << this->name_ << ". "
263		<< message << ~~std::~~endl;
	262	orxout(internal_warning, context::input) << "Warning while parsing binding for button/axis " << this->name_ << ". "
	263	<< message << endl;
264	264	}
265	265	}

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

-                      r8351
+                      r8858
 #include "util/Clock.h"
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "util/Exception.h"
 #include "InputState.h"
 …
             //       invalid right until the subclass has been constructed!
             oisDevice_->setEventCallback(static_cast<DeviceClass*>(this));
             COUT(4) << "Instantiated a " << this->getClassName() << std::endl;
+            orxout(verbose, context::input) << "Instantiated a " << this->getClassName() << endl;
+        }
 …
             catch (const OIS::Exception& ex)
+            {
                 COUT(1) << this->getClassName() << " destruction failed: " << ex.eText << std::endl
                         << "    Potential resource leak!" << std::endl;
+                orxout(internal_error, context::input) << this->getClassName() << " destruction failed: " << ex.eText << '\n'
+                                                       << "Potential resource leak!" << endl;
+            }
+        }

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

-                      r8729
+                      r8858
         RegisterRootObject(InputManager);
         CCOUT(4) << "Constructing..." << std::endl;
+        orxout(internal_status, context::input) << "InputManager: Constructing..." << endl;
         // Allocate space for the function call buffer
 …
         ModifyConsoleCommand(__CC_InputManager_name, __CC_reload_name).setObject(this);
         CCOUT(4) << "Construction complete." << std::endl;
+        orxout(internal_status, context::input) << "InputManager: Construction complete." << endl;
         internalState_ = Nothing;
+    }
 …
     void InputManager::loadDevices()
+    {
         CCOUT(4) << "Loading input devices..." << std::endl;
+        orxout(verbose, context::input) << "InputManager: Loading input devices..." << endl;
         // When loading the devices they should not already be loaded
 …
             // Exception-safety
             Loki::ScopeGuard guard = Loki::MakeGuard(OIS::InputManager::destroyInputSystem, oisInputManager_);
             CCOUT(4) << "Created OIS input manager." << std::endl;
+            orxout(verbose, context::input) << "Created OIS input manager." << endl;
             if (oisInputManager_->getNumberOfDevices(OIS::OISKeyboard) > 0)
 …
         this->updateActiveStates();
         CCOUT(4) << "Input devices loaded." << std::endl;
+        orxout(verbose, context::input) << "Input devices loaded." << endl;
+    }
 …
             catch (const std::exception& ex)
+            {
                 CCOUT(2) << "Warning: Failed to create Mouse:" << ex.what() << std::endl
                          << "Proceeding without mouse support." << std::endl;
+            }
+        }
         else
             CCOUT(2) << "Warning: No mouse found! Proceeding without mouse support." << std::endl;
+                orxout(user_warning, context::input) << "Failed to create Mouse:" << ex.what() << '\n'
+                                                     << "Proceeding without mouse support." << endl;
+            }
+        }
+        else
+            orxout(user_warning, context::input) << "No mouse found! Proceeding without mouse support." << endl;
+    }
 …
             catch (const std::exception& ex)
+            {
                 CCOUT(2) << "Warning: Failed to create joy stick: " << ex.what() << std::endl;
+                orxout(user_warning, context::input) << "Failed to create joy stick: " << ex.what() << endl;
+            }
+        }
 …
     InputManager::~InputManager()
+    {
         CCOUT(3) << "Destroying..." << std::endl;
+        orxout(internal_status, context::input) << "InputManager: Destroying..." << endl;
         // Leave all active InputStates (except "empty")
 …
         ModifyConsoleCommand(__CC_InputManager_name, __CC_reload_name).setObject(0);
         CCOUT(3) << "Destruction complete." << std::endl;
+        orxout(internal_status, context::input) << "InputManager: Destruction complete." << endl;
+    }
 …
     void InputManager::destroyDevices()
+    {
         CCOUT(4) << "Destroying devices..." << std::endl;
+        orxout(verbose, context::input) << "InputManager: Destroying devices..." << endl;
         BOOST_FOREACH(InputDevice*& device, devices_)
 …
             delete device;
             device = 0;
             CCOUT(4) << className << " destroyed." << std::endl;
+            orxout(verbose, context::input) << className << " destroyed." << endl;
+        }
         devices_.resize(InputDeviceEnumerator::FirstJoyStick);
 …
         catch (const OIS::Exception& ex)
+        {
             COUT(1) << "OIS::InputManager destruction failed" << ex.eText << std::endl
                     << "    Potential resource leak!" << std::endl;
+            orxout(internal_error, context::input) << "OIS::InputManager destruction failed" << ex.eText << '\n'
+                                                   << "Potential resource leak!" << endl;
+        }
         oisInputManager_ = NULL;
         internalState_ |= Bad;
         CCOUT(4) << "Destroyed devices." << std::endl;
+        orxout(verbose, context::input) << "Destroyed devices." << endl;
+    }
 …
+    {
         if (internalState_ & Calibrating)
             CCOUT(2) << "Warning: Cannot reload input system. Joy sticks are currently being calibrated." << std::endl;
+            orxout(internal_warning, context::input) << "Cannot reload input system. Joy sticks are currently being calibrated." << endl;
         else
             reloadInternal();
 …
     void InputManager::reloadInternal()
+    {
         CCOUT(4) << "Reloading ..." << std::endl;
+        orxout(verbose, context::input) << "InputManager: Reloading ..." << endl;
         this->destroyDevices();
 …
         internalState_ &= ~Bad;
         CCOUT(4) << "Reloading complete." << std::endl;
+        orxout(verbose, context::input) << "InputManager: Reloading complete." << endl;
+    }
 …
     void InputManager::calibrate()
+    {
         COUT(0) << "Move all joy stick axes fully in all directions." << std::endl
                 << "When done, put the axex in the middle position and press enter." << std::endl;
+        orxout(message) << "Move all joy stick axes fully in all directions." << '\n'
+                        << "When done, put the axex in the middle position and press enter." << endl;
         BOOST_FOREACH(InputDevice* device, devices_)
 …
         this->clearBuffers();
         COUT(0) << "Calibration has been stored." << std::endl;
+        orxout(message) << "Calibration has been stored." << endl;
+    }
 …
                     if (it->second->getPriority() == priority)
+                    {
                         COUT(2) << "Warning: Could not add an InputState with the same priority '"
                             << static_cast<int>(priority) << "' != 0." << std::endl;
+                        orxout(internal_warning, context::input) << "Could not add an InputState with the same priority '"
+                            << static_cast<int>(priority) << "' != 0." << endl;
                         return 0;
+                    }
 …
         else
+        {
             COUT(2) << "Warning: Could not add an InputState with the same name '" << name << "'." << std::endl;
+            orxout(internal_warning, context::input) << "Could not add an InputState with the same name '" << name << "'." << endl;
             return 0;
+        }
 …
         if (name == "empty")
+        {
             COUT(2) << "InputManager: Leaving the empty state is not allowed!" << std::endl;
+            orxout(internal_warning, context::input) << "InputManager: Leaving the empty state is not allowed!" << endl;
             return false;
+        }
 …
         if (name == "empty")
+        {
             COUT(2) << "InputManager: Removing the empty state is not allowed!" << std::endl;
+            orxout(internal_warning, context::input) << "InputManager: Removing the empty state is not allowed!" << endl;
             return false;
+        }
 …
         if (name == "empty")
+        {
             COUT(2) << "InputManager: Changing the empty state is not allowed!" << std::endl;
+            orxout(internal_warning, context::input) << "InputManager: Changing the empty state is not allowed!" << endl;
             return false;
+        }

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

r6536	r8858
80	80	}
81	81
82		~~COUT(4) << "Created OIS joy stick with ID " << deviceName_ << std::~~endl;
	82	orxout(verbose, context::input) << "Created OIS joy stick with ID " << deviceName_ << endl;
83	83
84	84	// Load calibration

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

-                      r8366
+                      r8858
 #include <sstream>
 #include "util/Convert.h"
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "util/Exception.h"
 #include "core/ConfigValueIncludes.h"
 …
     void KeyBinder::loadBindings()
+    {
         COUT(3) << "KeyBinder: Loading key bindings..." << std::endl;
+        orxout(internal_info, context::input) << "KeyBinder: Loading key bindings..." << endl;
         this->configFile_ = new ConfigFile(this->filename_, !PathConfig::buildDirectoryRun());
 …
+        }
         COUT(3) << "KeyBinder: Loading key bindings done." << std::endl;
+        orxout(internal_info, context::input) << "KeyBinder: Loading key bindings done." << endl;
+    }
 …
         else
+        {
             COUT(2) << "Could not find key/button/axis with name '" << name << "'." << std::endl;
+            orxout(internal_warning, context::input) << "Could not find key/button/axis with name '" << name << "'." << endl;
             return false;
+        }

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

-                      r7284
+                      r8858
 #include "KeyBinderManager.h"
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "util/Exception.h"
 #include "util/ScopedSingletonManager.h"
 …
         if (!this->bBinding_)
+        {
             COUT(0) << "Press any button/key or move a mouse/joystick axis" << std::endl;
+            orxout(message) << "Press any button/key or move a mouse/joystick axis" << endl;
             KeyDetector::getInstance().setCallback(createFunctor(&KeyBinderManager::keybindKeyPressed, this));
             InputManager::getInstance().enterState("detector");
 …
             if (keyName == "Keys.KeyEscape")
+            {
                 COUT(0) << "Keybinding aborted." << std::endl;
+                orxout(message) << "Keybinding aborted." << endl;
+            }
             else
+            {
                 COUT(0) << "Binding string \"" << command_ << "\" on key '" << keyName << "'" << std::endl;
+                orxout(message) << "Binding string \"" << command_ << "\" on key '" << keyName << "'" << endl;
                 this->currentBinder_->setBinding(command_, keyName, bTemporary_);
+            }

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

-                      r8351
+                      r8858
 SET_SOURCE_FILES(NETWORK_SRC_FILES
-  ChatListener.cc
   Client.cc
   ClientConnection.cc
 …
 SET_SOURCE_FILES(NETWORK_HDR_FILES
-  ChatListener.h
   Client.h
   ClientConnection.h
 …
   WANDiscovery.h
   MasterServerComm.h
+  NetworkChatListener.h
   NetworkFunction.h
   NetworkPrecompiledHeaders.h

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

-                      r8327
+                      r8858
 #include "util/Clock.h"
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "util/ScopedSingletonManager.h"
 #include "synchronisable/Synchronisable.h"
 …
+  }
-  bool Client::processChat(const std::string& message, unsigned int playerID)
+  {
-//    COUT(1) << "Player " << playerID << ": " << message << std::endl;
-    return true;
+  }
   void Client::printRTT()
+  {
     COUT(0) << "Round trip time to server is " << ClientConnection::getRTT() << " ms" << endl;
+  }
   /**
    * This function implements the method of sending a chat message to the server
+    orxout(message) << "Round trip time to server is " << ClientConnection::getRTT() << " ms" << endl;
+  }
+  /**
+   * @brief Sends a chat message to the server.
    * @param message message to be sent
+   * @return result(true/false)
+   * @param sourceID the ID of the sender
+   * @param targetID the ID of the receiver
    */
+  bool Client::chat(const std::string& message)
+  {
+    packet::Chat *m = new packet::Chat(message, Host::getPlayerID());
+    return m->send(static_cast<Host*>(this));
+  }
+  void Client::doSendChat(const std::string& message, unsigned int sourceID, unsigned int targetID)
+  {
+    // send the message to the server
+    packet::Chat* packet = new packet::Chat(message, sourceID, targetID);
+    packet->send(static_cast<Host*>(this));
+  }
+  /**
+   * @brief Gets called if a packet::Chat packet is received. Calls the parent function which passes the message to the listeners.
+   */
+  void Client::doReceiveChat(const std::string& message, unsigned int sourceID, unsigned int targetID)
+  {
+    // call the parent function which passes the message to the listeners
+    Host::doReceiveChat(message, sourceID, targetID);
+  }
   /**
 …
+    {
       timeSinceLastUpdate_ -= static_cast<unsigned int>( timeSinceLastUpdate_ / NETWORK_PERIOD ) * NETWORK_PERIOD;
-      //     COUT(3) << '.';
       if ( isConnected() && isSynched_ )
+      {
         COUT(4) << "popping partial gamestate: " << std::endl;
+        orxout(verbose, context::network) << "popping partial gamestate: " << endl;
 //         packet::Gamestate *gs = GamestateClient::getGamestate();
         if( GamestateManager::update() )
 …
         //assert(gs); <--- there might be the case that no data has to be sent, so its commented out now
 //         if(gs){
 //           COUT(4) << "client tick: sending gs " << gs << std::endl;
+//           orxout(verbose, context::network) << "client tick: sending gs " << gs << endl;
 //           if( !gs->send() )
 //             COUT(2) << "Problem adding partial gamestate to queue" << std::endl;
+//             orxout(internal_warning, context::network) << "Problem adding partial gamestate to queue" << endl;
 //         // gs gets automatically deleted by enet callback
 //         }
 …
     Game::getInstance().popState();
+  }
   void Client::processPacket(packet::Packet* packet)
+  {
 …
       packet->process(static_cast<Host*>(this));
+  }
+}

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

-                      r7801
+                      r8858
     Client();
     ~Client();
     static Client* getInstance(){ return singletonPtr_s; } // tolua_export
 …
     void queuePacket(ENetPacket* packet, int clientID, uint8_t channelID);
     virtual bool sendPacket( packet::Packet* packet ){ return packet->send( static_cast<Host*>(this) ); }
+    bool processChat(const std::string& message, unsigned int playerID);
+    virtual bool chat(const std::string& message);
+    virtual bool broadcast(const std::string& message) { return false; }
+    virtual void doSendChat(const std::string& message, unsigned int sourceID, unsigned int targetID);
+    virtual void doReceiveChat(const std::string& message, unsigned int sourceID, unsigned int targetID);
     virtual void printRTT();

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

-                      r8327
+                      r8858
 #define WIN32_LEAN_AND_MEAN
 #include <enet/enet.h>
 #include "util/Debug.h"
+#include "util/Output.h"
 namespace orxonox
 …
   void ClientConnection::setServerAddress( const std::string& serverAddress ) {
     if (enet_address_set_host (this->serverAddress_, serverAddress.c_str()) < 0)
         COUT(1) << "Error: Could not resolve \"" << serverAddress << "\"." << std::endl;
+        orxout(internal_error, context::network) << "Could not resolve \"" << serverAddress << "\"." << endl;
+  }
 …
     if ( this->host_ == NULL )
+    {
       COUT(1) << "ClientConnection: host_ == NULL" << std::endl;
+      orxout(internal_error, context::network) << "ClientConnection: host_ == NULL" << endl;
       // error handling
       return false;
 …
     assert( this->host_->socket4 != ENET_SOCKET_NULL || this->host_->socket6 != ENET_SOCKET_NULL );
     if (this->host_->socket4 == ENET_SOCKET_NULL)
         COUT(2) << "Warning: IPv4 Socket failed." << std::endl;
+        orxout(internal_warning, context::network) << "IPv4 Socket failed." << endl;
     else if (this->host_->socket6 == ENET_SOCKET_NULL)
         COUT(2) << "Warning: IPv6 Socket failed." << std::endl;
+        orxout(internal_warning, context::network) << "IPv6 Socket failed." << endl;
     else
         COUT(3) << "Info: Using IPv4 and IPv6 Sockets." << std::endl;
+        orxout(internal_info, context::network) << "Using IPv4 and IPv6 Sockets." << endl;
     this->server_ = enet_host_connect(this->host_, serverAddress_, NETWORK_CHANNEL_COUNT, 0);
     if ( this->server_==NULL )
+    {
       COUT(1) << "ClientConnection: server_ == NULL" << std::endl;
+      orxout(internal_error, context::network) << "ClientConnection: server_ == NULL" << endl;
       // error handling
       return false;
 …
+      }
+    }
     COUT(1) << "Could not connect to server" << endl;
+    orxout(user_error, context::network) << "Could not connect to server" << endl;
     return false;
+  }
 …
             break;
           case ENET_EVENT_TYPE_DISCONNECT:
             COUT(4) << "received disconnect confirmation from server" << endl;
+            orxout(verbose, context::network) << "received disconnect confirmation from server" << endl;
             this->connectionClosed();
             return true;
 …
+  {
     this->established_=false;
     COUT(1) << "Received disconnect Packet from Server!" << endl;
+    orxout(internal_error, context::network) << "Received disconnect Packet from Server!" << endl;
         // server closed the connection
     this->stopCommunicationThread();

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

r8327	r8858
144	144	while( outgoingEventsCount > 0 )
145	145	{
146		// ~~COUT(0~~) << "outgoing event" << endl;
	146	// orxout(verbose, context::network) << "outgoing event" << endl;
147	147	this->outgoingEventsMutex_->lock();
148	148	outgoingEvent outEvent = this->outgoingEvents_.front();

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

-                      r8407
+                      r8858
 #include "core/command/Executor.h"
 #include "core/GameMode.h"
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "util/Clock.h"
 #include "util/OrxAssert.h"
 …
     if( !this->sendPacket(ack))
+    {
       COUT(3) << "could not ack gamestate: " << gamestateID << std::endl;
+      orxout(internal_warning, context::network) << "could not ack gamestate: " << gamestateID << endl;
       return false;
+    }
     else
+    {
       COUT(5) << "acked a gamestate: " << gamestateID << std::endl;
+      orxout(verbose_more, context::network) << "acked a gamestate: " << gamestateID << endl;
       return true;
+    }
 …
       if( !peerIt->second.isSynched )
+      {
         COUT(5) << "Server: not sending gamestate" << std::endl;
+        orxout(verbose_more, context::network) << "Server: not sending gamestate" << endl;
         continue;
+      }
       COUT(5) << "client id: " << peerIt->first << std::endl;
       COUT(5) << "Server: doing gamestate gamestate preparation" << std::endl;
+      orxout(verbose_more, context::network) << "client id: " << peerIt->first << endl;
+      orxout(verbose_more, context::network) << "Server: doing gamestate gamestate preparation" << endl;
       int peerID = peerIt->first; //get client id
 …
 //     OrxVerify(gs->compressData(), "");
     clock.capture();
     COUT(5) << "diff and compress time: " << clock.getDeltaTime() << endl;
 //     COUT(5) << "sending gamestate with id " << gs->getID();
+    orxout(verbose_more, context::network) << "diff and compress time: " << clock.getDeltaTime() << endl;
+//     orxout(verbose_more, context::network) << "sending gamestate with id " << gs->getID();
 //     if(gamestate->isDiffed())
 //       COUT(5) << " and baseid " << gs->getBaseID() << endl;
+//       orxout(verbose_more, context::network) << " and baseid " << gs->getBaseID() << endl;
 //     else
 //       COUT(5) << endl;
+//       orxout(verbose_more, context::network) << endl;
     gs->setPeerID(peerID);
     destgamestate = gs;
 …
     if( gamestateID <= curid && curid != GAMESTATEID_INITIAL )
         return true;
 COUT(4) << "acking gamestate " << gamestateID << " for peerID: " << peerID << " curid: " << curid << std::endl;
+orxout(verbose, context::network) << "acking gamestate " << gamestateID << " for peerID: " << peerID << " curid: " << curid << endl;
     std::map<uint32_t, packet::Gamestate*>::iterator it2;
     for( it2=it->second.gamestates.begin(); it2!=it->second.gamestates.end(); )

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

-                      r8408
+                      r8858
 #include <string>
+#include "core/CoreIncludes.h"
 #include "core/ObjectList.h"
 #include "core/command/ConsoleCommand.h"
 #include "ChatListener.h"
+#include "NetworkChatListener.h"
 namespace orxonox {
 …
   static const std::string __CC_printRTT_name = "printRTT";
-  SetConsoleCommand("chat", &Host::Chat);
   SetConsoleCommand(__CC_printRTT_group, __CC_printRTT_name, &Host::printRTT);
 …
+  }
+  void Host::Chat(const std::string& message)
+  /**
+   * @brief Sends a chat message through the network.
+   * @param message message to be sent
+   * @param sourceID the ID of the sender
+   * @param targetID the ID of the receiver
+   */
+  void Host::sendChat(const std::string& message, unsigned int sourceID, unsigned int targetID)
+  {
+    if(instances_s.size()==0)
+    {
+      for (ObjectList<ChatListener>::iterator it = ObjectList<ChatListener>::begin(); it != ObjectList<ChatListener>::end(); ++it)
+        it->incomingChat(message, 0);
+//      return true;
+    }
+    else
+    {
+      bool result = true;
+      for( std::vector<Host*>::iterator it = instances_s.begin(); it!=instances_s.end(); ++it )
+      {
+        if( (*it)->isActive() )
+        {
+          if( !(*it)->chat(message) )
+            result = false;
+        }
+      }
+//      return result;
+    }
+    for( std::vector<Host*>::iterator it = instances_s.begin(); it!=instances_s.end(); ++it )
+      if( (*it)->isActive() )
+        (*it)->doSendChat(message, sourceID, targetID);
+  }
+  bool Host::Broadcast(const std::string& message)
+  /**
+   * @brief Gets called if a packet::Chat packet is received. Passes the message to the listeners.
+   */
+  void Host::doReceiveChat(const std::string& message, unsigned int sourceID, unsigned int targetID)
+  {
+    if(instances_s.size()==0)
+    {
+      for (ObjectList<ChatListener>::iterator it = ObjectList<ChatListener>::begin(); it != ObjectList<ChatListener>::end(); ++it)
+        it->incomingChat(message, NETWORK_PEER_ID_BROADCAST);
+      return true;
+    }
+    else
+    {
+      bool result = true;
+      for( std::vector<Host*>::iterator it = instances_s.begin(); it!=instances_s.end(); ++it )
+      {
+        if( (*it)->isActive() )
+        {
+          if( !(*it)->broadcast(message) )
+            result = false;
+        }
+      }
+      return result;
+    }
+    for (ObjectList<NetworkChatListener>::iterator it = ObjectList<NetworkChatListener>::begin(); it != ObjectList<NetworkChatListener>::end(); ++it)
+      it->incomingChat(message, sourceID);
+  }
-  bool Host::incomingChat(const std::string& message, unsigned int playerID)
+  {
-    for (ObjectList<ChatListener>::iterator it = ObjectList<ChatListener>::begin(); it != ObjectList<ChatListener>::end(); ++it)
-      it->incomingChat(message, playerID);
-    bool result = true;
-    for( std::vector<Host*>::iterator it = instances_s.begin(); it!=instances_s.end(); ++it )
+    {
-      if( (*it)->isActive() )
+      {
-        if( !(*it)->processChat(message, playerID) )
-          result = false;
+      }
+    }
-    return result;
+  }
   bool Host::isServer()
 …
     for (std::vector<Host*>::iterator it=instances_s.begin(); it!=instances_s.end(); ++it )
+    {
+      if( (*it)->isServer_() )
+        return true;
+      if( (*it)->isActive() )
+      {
+        if( (*it)->isServer_() )
+          return true;
+      }
+    }
     return false;
+  }
   Host* Host::getActiveInstance()
+  {
 …
+  //////////////////////////////////////////////////////////////////////////
+  // NetworkChatListener                                                  //
+  //////////////////////////////////////////////////////////////////////////
+  NetworkChatListener::NetworkChatListener()
+  {
+      RegisterRootObject(NetworkChatListener);
+  }
 }//namespace orxonox

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

-                      r8403
+                      r8858
 class _NetworkExport Host: public GamestateManager
+{
+  friend class packet::Chat;
   private:
-    //TODO add these functions or adequate
-    //virtual bool processChat(packet::Chat *message, unsigned int clientID)=0;
-    //virtual bool sendChat(packet::Chat *chat)=0;
     virtual void queuePacket(ENetPacket *packet, int clientID, uint8_t channelID)=0;
-    virtual bool chat(const std::string& message)=0;
-    virtual bool broadcast(const std::string& message)=0;
-    virtual bool processChat(const std::string& message, unsigned int playerID)=0;
     virtual bool isServer_()=0;
   protected:
 …
     virtual ~Host();
     void setActive( bool bActive ){ bIsActive_ = bActive; }
+//     static Host *instance_;
+    virtual void doSendChat(const std::string& message, unsigned int sourceID, unsigned int targetID)=0;
+    virtual void doReceiveChat(const std::string& message, unsigned int sourceID, unsigned int targetID)=0;
   public:
 …
     static bool running(){ return instances_s.size(); }
     static void addPacket(ENetPacket* packet, int clientID = NETWORK_PEER_ID_SERVER, uint8_t channelID = 0);
-    //static bool chat(std::string& message);
-//     static bool receiveChat(packet::Chat *message, unsigned int clientID);
     static unsigned int getPlayerID(){ return clientID_s; }
     static void setClientID(unsigned int id){ clientID_s = id; }
     static bool isServer();
+    static void Chat(const std::string& message);
+    static bool Broadcast(const std::string& message);
+    static bool incomingChat(const std::string& message, unsigned int playerID);
+    static void sendChat(const std::string& message, unsigned int sourceID, unsigned int targetID);
     virtual void printRTT()=0;
     bool isActive(){ return bIsActive_; }

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

-                      r8351
+                      r8858
 #include <cstring>
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "packet/ServerInformation.h"
 …
       this->host_ = enet_host_create( &bindAddress, 10, 0, 0, 0 );
       if ( this->host_ == NULL )
           COUT(1) << "LANDiscoverable: host_ == NULL" << std::endl;
+          orxout(internal_error, context::network) << "LANDiscoverable: host_ == NULL" << endl;
+    }
     else
 …
+      {
         case ENET_EVENT_TYPE_CONNECT:
             COUT(4) << "Received LAN discovery connect from client " << event.peer->host->receivedAddress << std::endl;
+            orxout(verbose, context::network) << "Received LAN discovery connect from client " << event.peer->host->receivedAddress << endl;
             break;
         case ENET_EVENT_TYPE_DISCONNECT:
 …
           if( strcmp( LAN_DISCOVERY_MESSAGE, (char*)event.packet->data ) == 0 )      // check for a suitable orxonox client
+          {
             COUT(3) << "Received LAN discovery message from client " << event.peer->host->receivedAddress << std::endl;
+            orxout(internal_info, context::network) << "Received LAN discovery message from client " << event.peer->host->receivedAddress << endl;
             packet::ServerInformation info;
             info.setServerName("Orxonox Server");

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

-                      r8706
+                      r8858
+ *
  *   Author:
  *      Fabian 'x3n' Landau
+ *      Oliver Scheuss
  *   Co-authors:
  *      ...
 …
     this->host_ = enet_host_create(NULL, 10, 0, 0, 0 );
     if ( this->host_ == NULL )
         COUT(1) << "LANDiscovery: host_ == NULL" << std::endl;
+        orxout(internal_error, context::network) << "LANDiscovery: host_ == NULL" << endl;
+  }
 …
     peer = enet_host_connect(this->host_, &address, 0, 0);
     if (peer == NULL)
         COUT(1) << "Error: Could not send LAN discovery to IPv4 Broadcast." << std::endl;
+        orxout(internal_error, context::network) << "Could not send LAN discovery to IPv4 Broadcast." << endl;
     /* IPv6 */
 …
     peer = enet_host_connect(this->host_, &address, 0, 0);
     if (peer == NULL)
         COUT(1) << "Error: Could not send LAN discovery to IPv6 Multicast." << std::endl;
+        orxout(internal_error, context::network) << "Could not send LAN discovery to IPv6 Multicast." << endl;
     ENetEvent event;
 …
         case ENET_EVENT_TYPE_CONNECT:
+        {
           COUT(4) << "Received LAN discovery connect from server " << event.peer->host->receivedAddress << std::endl;
+          orxout(verbose, context::network) << "Received LAN discovery connect from server " << event.peer->host->receivedAddress << endl;
           ENetPacket* packet = enet_packet_create(LAN_DISCOVERY_MESSAGE, strlen(LAN_DISCOVERY_MESSAGE)+1, ENET_PACKET_FLAG_RELIABLE);
           enet_peer_send(event.peer, 0, packet);
 …
+          {
             packet::ServerInformation info(&event);
             COUT(3) << "Received LAN discovery server information; Name: " << info.getServerName() << ", Address: " << info.getServerIP() << ", RTT: " << info.getServerRTT() << endl;
+            orxout(internal_info, context::network) << "Received LAN discovery server information; Name: " << info.getServerName() << ", Address: " << info.getServerIP() << ", RTT: " << info.getServerRTT() << endl;
             std::vector<packet::ServerInformation>::iterator it;
             for( it=this->servers_.begin(); it!=this->servers_.end(); ++it )

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

r8351	r8858
21	21	*
22	22	* Author:
23		* ~~Fabian 'x3n' Landau~~
	23	* Oliver Scheuss
24	24	* Co-authors:
25	25	* ...

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

-                      r8351
+                      r8858
   helper_output_debug( ENetEvent *event, char *addrconv )
+  {
+    COUT(4) << "A packet of length"
+    orxout(verbose, context::master_server)
+      << "A packet of length"
       << event->packet->dataLength
       << " containing "
 …
       << addrconv
       << " on channel "
       << event->channelID << "\n";
+      << event->channelID << endl;
+  }
 …
           + MSPROTO_SERVERLIST_ITEM_LEN + 2,1 );
       if( !tosend )
       { COUT(2) << "Masterserver.cc: Memory allocation failed.\n";
+      { orxout(internal_warning, context::master_server) << "Masterserver.cc: Memory allocation failed." << endl;
         continue;
+      }
 …
   { /* check for bad parameters */
     if( !event )
     { COUT(2) << "MasterServer::eventConnect: No event given.\n" ;
+    { orxout(internal_warning, context::master_server) << "MasterServer::eventConnect: No event given." << endl;
       return -1;
+    }
 …
     /* output debug info */
     COUT(4) << "A new client connected from "
+    orxout(verbose, context::master_server) << "A new client connected from "
       << addrconv
       << " on port "
       << event->peer->address.port << "\n";
+      << event->peer->address.port << endl;
     /* store string form of address here */
 …
   { /* check for bad parameters */
     if( !event )
     { COUT(2) << "No event given.\n";
+    { orxout(internal_warning, context::master_server) << "No event given." << endl;
       return -1;
+    }
     /* output that the disconnect happened */
     COUT(4) << (char*)event->peer->data << " disconnected.\n";
+    orxout(verbose, context::master_server) << (char*)event->peer->data << " disconnected." << endl;
     /* create string from peer data */
 …
   { /* validate packet */
     if( !event || !(event->packet) || !(event->peer) )
     { COUT(2) << "No complete event given.\n";
+    { orxout(internal_warning, context::master_server) << "No complete event given." << endl;
       return -1;
+    }
 …
         /* tell people we did so */
         COUT(2) << "Added new server to list: " <<
           packet::ServerInformation( event ).getServerIP() << "\n";
+        orxout(internal_info, context::master_server) << "Added new server to list: " <<
+          packet::ServerInformation( event ).getServerIP() << endl;
+      }
 …
         /* tell the user */
         COUT(2) << "Removed server " << name << " from list.\n";
+        orxout(internal_info, context::master_server) << "Removed server " << name << " from list." << endl;
+      }
 …
     if( event == NULL )
+    {
       COUT(1) << "Could not create ENetEvent structure, exiting.\n";
+      orxout(user_error, context::master_server) << "Could not create ENetEvent structure, exiting." << endl;
       exit( EXIT_FAILURE );
+    }
 …
     /***** INITIALIZE NETWORKING *****/
     if( enet_initialize () != 0)
     { COUT(1) << "An error occurred while initializing ENet.\n";
+    { orxout(user_error, context::master_server) << "An error occurred while initializing ENet." << endl;
       exit( EXIT_FAILURE );
+    }
 …
     /* see if creation worked */
     if( !this->server )
     { COUT(1) <<
         "An error occurred while trying to create an ENet server host.\n";
+    { orxout(user_error, context::master_server) <<
+        "An error occurred while trying to create an ENet server host." << endl;
       exit( EXIT_FAILURE );
+    }
 …
     /* tell people we're now initialized */
     COUT(0) << "MasterServer initialized, waiting for connections.\n";
+    orxout(internal_status, context::master_server) << "MasterServer initialized, waiting for connections." << endl;
+  }

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

-                      r8351
+                      r8858
 #include "MasterServerComm.h"
+#include "util/Debug.h"
+#include "util/Output.h"
+#include "WANDiscovery.h"
 namespace orxonox
 …
     /* initialize Enet */
     if( enet_initialize () != 0 )
     { COUT(1) << "An error occurred while initializing ENet.\n";
+    { orxout(internal_error, context::master_server) << "An error occurred while initializing ENet." << endl;
       return 1;
+    }
 …
     /* see if it worked */
     if (this->client == NULL)
     { COUT(1) << "An error occurred while trying to create an "
         << "ENet client host.\n";
+    { orxout(internal_error, context::master_server) << "An error occurred while trying to create an "
+        << "ENet client host." << endl;
       return 1;
+    }
 …
     if( this->peer == NULL )
     { COUT(2) << "ERROR: No available peers for initiating an ENet"
         << " connection.\n";
+    { orxout(internal_error, context::master_server) << "No available peers for initiating an ENet"
+        << " connection." << endl;
       return -1;
+    }
 …
     if (enet_host_service (this->client, &this->event, 500) > 0 &&
         this->event.type == ENET_EVENT_TYPE_CONNECT )
       COUT(3) << "Connection to master server succeeded.\n";
+      orxout(internal_info, context::master_server) << "Connection to master server succeeded." << endl;
     else
+    {
       enet_peer_reset (this->peer);
       COUT(2) << "ERROR: connection to " << address << " failed.\n";
+      orxout(internal_warning, context::master_server) << "Connection to " << address << " failed." << endl;
       return -1;
+    }
 …
         case ENET_EVENT_TYPE_DISCONNECT:
           COUT(4) << "Disconnect from master server successful.\n";
+          orxout(verbose, context::master_server) << "Disconnect from master server successful." << endl;
           return 0;
         default: break;
 …
    * so we can also make callbacks from objects
    */
+  int MasterServerComm::pollForReply( int (*callback)( char*, ENetEvent* ),
+    int delayms )
+  int MasterServerComm::pollForReply( WANDiscovery* listener, int delayms )
+  {
     /* see whether anything happened */
     /* WORK MARK REMOVE THIS OUTPUT */
     COUT(2) << "polling masterserver...\n";
+    orxout(verbose, context::master_server) << "polling masterserver..." << endl;
     /* address buffer */
 …
           addrconv = (char *) calloc( 50, 1 );
           if( !addrconv )
           { COUT(2) << "MasterServerComm.cc: Could not allocate memory!\n";
+          { orxout(internal_warning, context::master_server) << "MasterServerComm.cc: Could not allocate memory!" << endl;
             break;
+          }
 …
           /* DEBUG */
           COUT(3) << "MasterServer Debug: A packet of length "
+          orxout(verbose, context::master_server) << "MasterServer Debug: A packet of length "
             << this->event.packet->dataLength
             << " containing " << this->event.packet->data
 …
           /* call the supplied callback, if any. */
           if( (*callback) != NULL )
             retval = (*callback)( addrconv, &(this->event) );
+          if( listener != NULL )
+            retval = listener->rhandler( addrconv, &(this->event) );
           /* clean up */

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

r8351	r8858
93	93	*
94	94	* Poll the master server for new data and act accordingly */
95		int pollForReply( ~~int (callback)( char, ENetEvent* )~~, int delayms );
	95	int pollForReply( WANDiscovery* listener, int delayms );
96	96
97	97	private:

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

r8351	r8858
52	52	#include <set> // 20
53	53
54		#include "util/~~Debug~~.h" // 20
	54	#include "util/Output.h" // 20
55	55	#include <loki/TypeTraits.h> // 18
56	56

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

-                      r8351
+                      r8858
 namespace orxonox
+{
-  class ChatListener;
   class Client;
   class ClientConnection;
 …
   class GamestateManager;
   class Host;
+  class MasterServer;
+  class MasterServerComm;
+  class NetworkChatListener;
   class NetworkFunctionBase;
   struct NetworkFunctionPointer;
 …
   class NetworkMemberFunction;
   class NetworkMemberFunctionBase;
+  class PeerList;
   class Server;
   class ServerConnection;
   class TrafficControl;
+  class WANDiscoverable;
+  class WANDiscovery;
   // packet

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

-                      r8351
+                      r8858
 #include "PeerList.h"
+#include <network/packet/ServerInformation.h>
 #include <cstdio>
+#include "util/Output.h"
+#include "network/packet/ServerInformation.h"
 namespace orxonox
 …
   { /* error correction */
     if( toadd == NULL )
     { fprintf( stderr, "PeerList::addPeer: empty peer given.\n" );
+    { orxout(internal_error, context::master_server) << "PeerList::addPeer: empty peer given." << endl;
       return -1;
+    }

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

-                      r8706
+                      r8858
 #include "util/Clock.h"
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "core/ObjectList.h"
 #include "core/command/Executor.h"
 …
 #include "packet/Gamestate.h"
 #include "packet/Welcome.h"
-#include "ChatListener.h"
 // #include "ClientInformation.h"
 #include "FunctionCallManager.h"
 #include "GamestateManager.h"
-#include "WANDiscovery.h"
 namespace orxonox
 …
+  }
-  /** helper that connects to the master server */
-  void Server::helper_ConnectToMasterserver()
+  {
-//     WANDiscovery::getInstance().msc.sendRequest( MSPROTO_GAME_SERVER " "
-//       MSPROTO_REGISTER_SERVER );
+  }
   /**
   * This function opens the server by creating the listener thread
 …
+  {
     Host::setActive(true);
     COUT(4) << "opening server" << endl;
+    orxout(verbose, context::network) << "opening server" << endl;
     this->openListener();
     /* make discoverable on LAN */
     LANDiscoverable::setActivity(true);
 …
     /* make discoverable on WAN */
     WANDiscoverable::setActivity(true);
-    /* TODO this needs to be optional, we need a switch from the UI to
-     * enable/disable this
-     */
-//     helper_ConnectToMasterserver();
     /* done */
 …
+  {
     Host::setActive(false);
     COUT(4) << "closing server" << endl;
+    orxout(verbose, context::network) << "closing server" << endl;
     this->disconnectClients();
     this->closeListener();
     /* tell master server we're closing */
     COUT(2) << "disconnecting." << endl;
     WANDiscoverable::setActivity(false);
     COUT(2) << "disconnecting done" << endl;
+    orxout(internal_info, context::network) << "disconnecting." << endl;
+    WANDiscoverable::setActivity(false);
+    orxout(internal_info, context::network) << "disconnecting done" << endl;
     LANDiscoverable::setActivity(false);
     return;
+  }
-  bool Server::processChat(const std::string& message, unsigned int playerID)
+  {
-//     ClientInformation *temp = ClientInformation::getBegin();
-    packet::Chat *chat;
-//     while(temp){
-    chat = new packet::Chat(message, playerID);
-    chat->setPeerID(NETWORK_PEER_ID_BROADCAST);
-    chat->send( static_cast<Host*>(this) );
-//         COUT(3) << "could not send Chat message to client ID: " << temp->getID() << std::endl;
-//       temp = temp->next();
-//     }
-//    COUT(1) << "Player " << playerID << ": " << message << std::endl;
-    return true;
+  }
-  /* handle incoming data */
-  int rephandler( char *addr, ENetEvent *ev )
+  {
-    /* reply to pings */
-    if( !strncmp( (char *)ev->packet->data, MSPROTO_PING_GAMESERVER,
-      MSPROTO_PING_GAMESERVER_LEN ) )
-      //this->msc.sendRequest( MSPROTO_ACK );
-      /* NOTE implement this after pollForReply
-       * reimplementation
-       */
-      return 0;
-    /* done handling, return all ok code 0 */
-    return 0;
+  }
-  void Server::helper_HandleMasterServerRequests()
+  {
-    /* poll the master server for replies and see whether something
-     * has to be done or changed.
-     */
-    //WANDiscovery::getInstance().msc.pollForReply( rhandler, 10 );
+  }
 …
     // receive and process incoming discovery packets
     LANDiscoverable::update();
-    // receive and process requests from master server
-    /* todo */
-    //helper_HandleMasterServerRequests();
     if ( GamestateManager::hasPeers() )
 …
+  {
 //     for( ClientInformation* temp=ClientInformation::getBegin(); temp!=0; temp=temp->next() )
 //       COUT(0) << "Round trip time to client with ID: " << temp->getID() << " is " << temp->getRTT() << " ms" << endl;
+//       orxout(message) << "Round trip time to client with ID: " << temp->getID() << " is " << temp->getRTT() << " ms" << endl;
+  }
 …
       return;
     GamestateManager::update();
 //     COUT(5) << "Server: one gamestate update complete, goig to sendGameState" << std::endl;
     //std::cout << "updated gamestate, sending it" << std::endl;
+//     orxout(verbose_more, context::network) << "Server: one gamestate update complete, goig to sendGameState" << endl;
+    //orxout(verbose_more, context::network) << "updated gamestate, sending it" << endl;
     //if(clients->getGamestateID()!=GAMESTATEID_INITIAL)
     sendGameStates();
     sendObjectDeletes();
 //     COUT(5) << "Server: one sendGameState turn complete, repeat in next tick" << std::endl;
     //std::cout << "sent gamestate" << std::endl;
+//     orxout(verbose_more, context::network) << "Server: one sendGameState turn complete, repeat in next tick" << endl;
+    //orxout(verbose_more, context::network) << "sent gamestate" << endl;
+  }
 …
       return true;  //everything ok (no deletes this tick)
+    }
 //     COUT(3) << "sending DeleteObjects" << std::endl;
+//     orxout(verbose, context::network) << "sending DeleteObjects" << endl;
 //     while(temp != NULL){
 //       if( !(temp->getSynched()) )
 //       {
 //         COUT(5) << "Server: not sending gamestate" << std::endl;
+//         orxout(verbose_more, context::network) << "Server: not sending gamestate" << endl;
 //         temp=temp->next();
 //         continue;
 …
     del->setPeerID(NETWORK_PEER_ID_BROADCAST);
     if ( !del->send( static_cast<Host*>(this) ) )
       COUT(3) << "Server: could not broadcast deleteObjects packet" << std::endl;
+      orxout(internal_warning, context::network) << "Server: could not broadcast deleteObjects packet" << endl;
 //       temp=temp->next();
       // gs gets automatically deleted by enet callback
 …
+  {
 //     static unsigned int newid=1;
 //
 //     COUT(2) << "Server: adding client" << std::endl;
+//
+//     orxout(internal_info, context::network) << "Server: adding client" << endl;
 //     ClientInformation *temp = ClientInformation::insertBack(new ClientInformation);
 //     if(!temp)
 //     {
 //       COUT(2) << "Server: could not add client" << std::endl;
+//       orxout(internal_warning, context::network) << "Server: could not add client" << endl;
 //     }
 //     temp->setID(newid);
 …
 //     ++newid;
     COUT(3) << "Server: added client id: " << peerID << std::endl;
+    orxout(internal_info, context::network) << "Server: added client id: " << peerID << endl;
     createClient(peerID);
+}
 …
   void Server::removePeer(uint32_t peerID)
+  {
     COUT(4) << "removing client from list" << std::endl;
+    orxout(verbose, context::network) << "removing client from list" << endl;
 //     ClientInformation *client = ClientInformation::findClient(&event->peer->address);
 //     if(!client)
 …
 //     }
+  }
   void Server::processPacket(packet::Packet* packet)
+  {
 …
 //     if(!temp)
 //     {
 //       COUT(2) << "Server. could not create client with id: " << clientID << std::endl;
+//       orxout(internal_error, context::network) << "Server. could not create client with id: " << clientID << endl;
 //       return false;
 //     }
 //     COUT(4) << "Con.Man: creating client id: " << temp->getID() << std::endl;
+//     orxout(verbose, context::network) << "Con.Man: creating client id: " << temp->getID() << endl;
     // synchronise class ids
 …
 //     temp->setSynched(true);
     GamestateManager::setSynched(clientID);
     COUT(4) << "sending welcome" << std::endl;
+    orxout(verbose, context::network) << "sending welcome" << endl;
     packet::Welcome *w = new packet::Welcome(clientID);
     w->setPeerID(clientID);
 …
+  }
+  bool Server::chat(const std::string& message)
+  {
+      return this->sendChat(message, Host::getPlayerID());
+  }
+  bool Server::broadcast(const std::string& message)
+  {
+      return this->sendChat(message, NETWORK_PEER_ID_BROADCAST);
+  }
+  bool Server::sendChat(const std::string& message, unsigned int clientID)
+  {
+//     ClientInformation *temp = ClientInformation::getBegin();
+    packet::Chat *chat;
+//     while(temp)
+    {
+      chat = new packet::Chat(message, clientID);
+      chat->setPeerID(NETWORK_PEER_ID_BROADCAST);
+      chat->send( static_cast<Host*>(this) );
+//         COUT(3) << "could not send Chat message to client ID: " << temp->getID() << std::endl;
+//       temp = temp->next();
+    }
+//    COUT(1) << "Player " << Host::getPlayerID() << ": " << message << std::endl;
+    for (ObjectList<ChatListener>::iterator it = ObjectList<ChatListener>::begin(); it != ObjectList<ChatListener>::end(); ++it)
+      it->incomingChat(message, clientID);
+    return true;
+  /**
+   * @brief Sends a chat message to the given target ID.
+   * @param message message to be sent
+   * @param sourceID the ID of the sender
+   * @param targetID the ID of the receiver
+   */
+  void Server::doSendChat(const std::string& message, unsigned int sourceID, unsigned int targetID)
+  {
+    // check if the target exists. just ignore the message otherwise
+    if (!this->isValidTarget(targetID)) // TODO: remove this if an invalid clientIDs don't trigger assertions anymore
+      return;
+    // send the message to the target
+    packet::Chat* packet = new packet::Chat(message, sourceID, targetID);
+    packet->setPeerID(targetID);
+    packet->send( static_cast<Host*>(this) );
+    // if the target is (or includes) this host as well, call the parent function which passes the message to the listeners
+    if (targetID == NETWORK_PEER_ID_BROADCAST || targetID == Host::getPlayerID())
+      Host::doReceiveChat(message, sourceID, targetID);
+  }
+  /**
+   * @brief Gets called if a packet::Chat packet is received. Forwards the packet to the target
+   * and calls the parent function if necessary.
+   */
+  void Server::doReceiveChat(const std::string& message, unsigned int sourceID, unsigned int targetID)
+  {
+      this->doSendChat(message, sourceID, targetID);
+  }
+  /**
+   * @brief Returns true if the target ID is in the list of clients (or if it
+   * corresponds to the broadcast or the server ID).
+   */
+  bool Server::isValidTarget(unsigned int targetID)
+  {
+    if (targetID == NETWORK_PEER_ID_BROADCAST || targetID == NETWORK_PEER_ID_SERVER)
+      return true;
+    std::vector<uint32_t>::iterator it;
+    for( it=this->clientIDs_.begin(); it!=this->clientIDs_.end(); ++it )
+      if( *it == targetID )
+        return true;
+    return false;
+  }
 …
+    }
     assert(failures<10);
     COUT(4) << "syncClassid:\tall synchClassID packets have been sent" << std::endl;
+    orxout(verbose, context::network) << "syncClassid:\tall synchClassID packets have been sent" << endl;
+  }

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

-                      r8351
+                      r8858
 #include "LANDiscoverable.h"
 #include "WANDiscoverable.h"
-// #include "MasterServerComm.h"
-// #include "MasterServerProtocol.h"
 …
     ~Server();
-    /* helpers */
-    void helper_ConnectToMasterserver();
-    void helper_HandleMasterServerRequests();
-    int replyhandler( char *addr, ENetEvent *ev );
     void open();
     void close();
-    bool processChat(const std::string& message, unsigned int playerID);
     void queuePacket(ENetPacket *packet, int clientID, uint8_t channelID);
     virtual bool sendPacket( packet::Packet* packet ){ return packet->send( static_cast<Host*>(this) ); }
 …
     bool sendGameStates();
     bool sendObjectDeletes();
     virtual bool chat(const std::string& message);
     virtual bool broadcast(const std::string& message);
     bool sendChat(const std::string& message, unsigned int clientID);
+    bool isValidTarget(unsigned int targetID);
+    virtual void doSendChat(const std::string& message, unsigned int sourceID, unsigned int targetID);
+    virtual void doReceiveChat(const std::string& message, unsigned int sourceID, unsigned int targetID);
     void syncClassid(unsigned int clientID);

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

-                      r8358
+                      r8858
 #include <enet/enet.h>
 #include "util/Debug.h"
+#include "util/Output.h"
 #include <util/Sleep.h>
 // #include "ClientInformation.h"
 …
+  {
     if (enet_address_set_host (this->bindAddress_, bindAddress.c_str()) < 0)
         COUT(1) << "Error: Could not resolve \"" << bindAddress << "\"." << std::endl;
+        orxout(internal_error, context::network) << "Could not resolve \"" << bindAddress << "\"." << endl;
+  }
 …
     if ( this->host_ == NULL )
+    {
         COUT(1) << "ServerConnection: host_ == NULL" << std::endl;
+        orxout(internal_error, context::network) << "ServerConnection: host_ == NULL" << endl;
         return false;
+    }
 …
     assert( this->host_->socket4 != ENET_SOCKET_NULL || this->host_->socket6 != ENET_SOCKET_NULL );
     if (this->host_->socket4 == ENET_SOCKET_NULL)
         COUT(2) << "Warning: IPv4 Socket failed." << std::endl;
+        orxout(internal_warning, context::network) << "IPv4 Socket failed." << endl;
     else if (this->host_->socket6 == ENET_SOCKET_NULL)
         COUT(2) << "Warning: IPv6 Socket failed." << std::endl;
+        orxout(internal_warning, context::network) << "IPv6 Socket failed." << endl;
     else
         COUT(3) << "Info: Using IPv4 and IPv6 Sockets." << std::endl;
+        orxout(internal_info, context::network) << "Using IPv4 and IPv6 Sockets." << endl;
     // start communication thread
 …
 //       ClientInformation *temp = ClientInformation::findClient(clientID);
 //       if(!temp){
 //         COUT(3) << "C.Man: addPacket findClient failed" << std::endl;
+//         orxout(internal_warning, context::network) << "C.Man: addPacket findClient failed" << endl;
 //       }
       Connection::addPacket(packet, clientID, channelID);

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

r6417	r8858
287	287	{
288	288	std::list<obj>::iterator it;
289		~~COUT(0~~) << "=========== Objectlist ===========" << endl;
	289	orxout(debug_output, context::network) << "=========== Objectlist ===========" << endl;
290	290	for( it=list.begin(); it!=list.end(); it++)
291		~~COUT(0~~) << "ObjectID: " << it->objID << " creatorID: " << it->objCreatorID << " Priority: " << clientListPerm_[clientID][it->objID].objValuePerm + clientListPerm_[clientID][it->objID].objValueSched << " size: " << it->objSize << endl;
	291	orxout(debug_output, context::network) << "ObjectID: " << it->objID << " creatorID: " << it->objCreatorID << " Priority: " << clientListPerm_[clientID][it->objID].objValuePerm + clientListPerm_[clientID][it->objID].objValueSched << " size: " << it->objSize << endl;
292	292	}
293	293

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

-                      r8351
+                      r8858
+ *
  *   Author:
  *      Fabian 'x3n' Landau (original)
+ *      Sandro 'smerkli' Merkli
  *   Co-authors:
+ *      Sandro 'smerkli' Merkli (adaptions to WAN)
+ *      ...
+ *      Oliver Scheuss (original)
+ *
  */
 …
+  {
     /* debugging output */
     COUT(4) << "Creating WANDiscoverable.\n";
+    orxout(verbose, context::master_server) << "Creating WANDiscoverable." << endl;
     /* register object in orxonox */
 …
     if( msc.initialize() )
+    {
       COUT(2) << "Error: could not initialize master server communications!\n";
+      orxout(internal_error, context::master_server) << "Could not initialize master server communications!" << endl;
       return false;
+    }
 …
     if( msc.connect( this->msaddress.c_str(), ORX_MSERVER_PORT ) )
+    {
       COUT(2) << "Error: could not connect to master server at "
                  << this->msaddress << std::endl;
+      orxout(internal_error, context::master_server) << "Could not connect to master server at "
+                 << this->msaddress << endl;
       return false;
+    }
     /* debugging output */
     COUT(4) << "Initialization of WANDiscoverable complete.\n";
+    orxout(verbose, context::master_server) << "Initialization of WANDiscoverable complete." << endl;

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

-                      r8729
+                      r8858
  *   Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author: Fabian 'x3n' Landau (original) Co-authors: Sandro 'smerkli' Merkli
+ *   (copied and adapted to WAN)
+ *   Author:
+ *      Sandro 'smerkli' Merkli
+ *   Co-authors:
+ *      Oliver Scheuss (original)
+ *
  */

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

-                      r8351
+                      r8858
+ *
  *   Author:
  *      Fabian 'x3n' Landau (original)
+ *      Sandro 'smerkli' Merkli
  *   Co-authors:
+ *      Sandro 'smerkli' Merkli (adaptions to WAN)
+ *      ...
+ *      Oliver Scheuss (original)
+ *
  */
 …
 #include <cstring>
-#include "util/ScopedSingletonManager.h"
 #include "core/CoreIncludes.h"
 …
 namespace orxonox
+{
-  ManageScopedSingleton(WANDiscovery, ScopeID::Graphics, true);
   WANDiscovery::WANDiscovery()
+  {
     /* debugging output */
     COUT(4) << "Creating WANDiscovery.\n";
+    orxout(verbose, context::master_server) << "Creating WANDiscovery." << endl;
     /* register object in orxonox */
 …
     /* initialize it and see if it worked */
     if( msc.initialize() )
       COUT(2) << "Error: could not initialize master server communications!\n";
+      orxout(internal_error, context::master_server) << "Could not initialize master server communications!" << endl;
     /* connect and see if it worked */
     if( msc.connect( this->msaddress.c_str(), ORX_MSERVER_PORT ) )
       COUT(2) << "Error: could not connect to master server at "
         << this->msaddress << std::endl;
+      orxout(internal_error, context::master_server) << "Could not connect to master server at "
+        << this->msaddress << endl;
     /* debugging output */
     COUT(4) << "Initialization of WANDiscovery complete.\n";
+    orxout(verbose, context::master_server) << "Initialization of WANDiscovery complete." << endl;
+  }
 …
   /* callback for the network reply poller */
   int rhandler( char *addr, ENetEvent *ev )
+  int WANDiscovery::rhandler( char *addr, ENetEvent *ev )
+  {
     /* error recognition */
     if( !ev || !ev->packet || !ev->packet->data )
     { COUT(2) << "Bad arguments received in WANDiscovery's reply handler.\n";
+    { orxout(internal_warning, context::master_server) << "Bad arguments received in WANDiscovery's reply handler." << endl;
       return 0;
+    }
 …
       /* add to list */
       WANDiscovery::getInstance().servers_.push_back( toadd );
+      this->servers_.push_back( toadd );
+    }
     else if( !strncmp( (char*)ev->packet->data, MSPROTO_SERVERLIST_END,
 …
+    {
       /* poll for reply and act according to what was received */
       switch( this->msc.pollForReply( rhandler, 500 ) )
+      switch( this->msc.pollForReply( this, 500 ) )
       { case 0: /* no event occured, decrease timeout */
           --i; break;

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

-                      r8351
+                      r8858
  *   Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author: Fabian 'x3n' Landau (original) Co-authors: Sandro 'smerkli' Merkli
+ *   (copied and adapted to WAN)
+ *   Author:
+ *      Sandro 'smerkli' Merkli
+ *   Co-authors:
+ *      Oliver Scheuss (original)
+ *
  */
 …
 #include "packet/ServerInformation.h"
 #include "core/ConfigFileManager.h"
-#include "util/Singleton.h"
 #include "core/OrxonoxClass.h"
 #include "core/ConfigValueIncludes.h"
 …
   class _NetworkExport WANDiscovery
 // tolua_end
     : public Singleton<WANDiscovery>, public OrxonoxClass
+    : public OrxonoxClass
   { // tolua_export
-    friend class Singleton<WANDiscovery>;
     public:
       /** constructor */
       WANDiscovery();
+      WANDiscovery(); // tolua_export
       /** destructor */
 …
       std::string getServerListItemIP( unsigned int index ); // tolua_export
-      /** \return an instance of WANDiscovery
+       *
-       * Create and return an instance of WANDiscovery.
-       */
-      static WANDiscovery& getInstance() { return Singleton<WANDiscovery>::getInstance(); } // tolua_export
       /* todo: might make this private and use getter/setter methods
        * at some later time.
 …
       /** Master server communications object */
       MasterServerComm msc;
+      int rhandler( char *addr, ENetEvent *ev );
     private:
-      /** Singleton pointer */
-      static WANDiscovery* singletonPtr_s;
       /** master server address */
       std::string msaddress;

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

-                      r7801
+                      r8858
 #include "Acknowledgement.h"
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "network/GamestateHandler.h"
 #include "network/Host.h"
 …
 bool Acknowledgement::process(orxonox::Host* host){
   COUT(5) << "processing ACK with ID: " << getAckID() << endl;
+  orxout(verbose_more, context::packets) << "processing ACK with ID: " << getAckID() << endl;
   bool b = host->ackGamestate(getAckID(), peerID_);
   delete this;

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

-                      r7801
+                      r8858
 /* Some lengths */
+#define   _PACKETID         0
+const int _PLAYERID     =   _PACKETID + sizeof(Type::Value);
+#define   _MESSAGELENGTH    _PLAYERID + sizeof(uint32_t)
+#define   _MESSAGE          _MESSAGELENGTH + sizeof(uint32_t)
+#define _PACKETID         0
+#define _SOURCEID         _PACKETID + sizeof(Type::Value)
+#define _TARGETID         _SOURCEID + sizeof(uint32_t)
+#define _MESSAGELENGTH    _TARGETID + sizeof(uint32_t)
+#define _MESSAGE          _MESSAGELENGTH + sizeof(uint32_t)
 Chat::Chat( const std::string& message, unsigned int playerID )
+Chat::Chat( const std::string& message, unsigned int sourceID, unsigned int targetID )
  : Packet()
+{
 …
   *(Type::Value *)(data_ + _PACKETID ) = Type::Chat;
+  *(unsigned int *)(data_ + _PLAYERID ) = playerID;
+  *(unsigned int *)(data_ + _SOURCEID ) = sourceID;
+  *(unsigned int *)(data_ + _TARGETID ) = targetID;
   *(unsigned int *)(data_ + _MESSAGELENGTH ) = messageLength_;
 …
 bool Chat::process(orxonox::Host* host){
   bool b = host->incomingChat(std::string((const char*)data_+_MESSAGE), *(uint32_t *)(data_+_PLAYERID));
+  host->doReceiveChat(std::string((const char*)data_+_MESSAGE), *(uint32_t *)(data_+_SOURCEID), *(uint32_t *)(data_+_TARGETID));
   delete this;
   return b;
+  return true;
+}

code/trunk/src/libraries/network/packet/Chat.h

r7801	r8858
42	42	public:
43	43	/* constructors */
44		Chat( const std::string& message, unsigned int ~~player~~ID );
	44	Chat( const std::string& message, unsigned int sourceID, unsigned int targetID );
45	45	Chat( uint8_t* data, unsigned int clientID );
46	46

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

-                      r7801
+                      r8858
   assert(tempsize==packetSize);
   COUT(5) << "classid packetSize is " << packetSize << endl;
+  orxout(verbose_more, context::packets) << "classid packetSize is " << packetSize << endl;
+}
 …
   Identifier::clearNetworkIDs();
   COUT(4) << "=== processing classids: " << endl;
+  orxout(verbose, context::packets) << "=== processing classids: " << endl;
   std::pair<uint32_t, std::string> tempPair;
   Identifier *id;
 …
     classname = temp+2*sizeof(uint32_t);
     id=ClassByString( std::string((const char*)classname) );
     COUT(3) << "processing classid: " << networkID << " name: " << classname << " id: " << id << std::endl;
+    orxout(internal_info, context::packets) << "processing classid: " << networkID << " name: " << classname << " id: " << id << endl;
     if(id==NULL){
       COUT(0) << "Received a bad classname" << endl;
+      orxout(user_error, context::packets) << "Received a bad classname" << endl;
       abort();
+    }

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

-                      r7801
+                      r8858
 #include <cassert>
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "network/synchronisable/Synchronisable.h"
 …
   if(number==0)
     return false;
   COUT(4) << "sending DeleteObjects: ";
+  orxout(verbose, context::packets) << "sending DeleteObjects: ";
   unsigned int size = sizeof(Type::Value) + sizeof(uint32_t)*(number+1);
   data_ = new uint8_t[size];
 …
     unsigned int temp = Synchronisable::popDeletedObject();
     *reinterpret_cast<uint32_t*>(tdata) = temp;
     COUT(4) << temp << ' ';
+    orxout(verbose, context::packets) << temp << ' ';
     tdata += sizeof(uint32_t);
+  }
   COUT(4) << std::endl;
+  orxout(verbose, context::packets) << endl;
   return true;
+}
 …
   for(unsigned int i=0; i<*(unsigned int *)(data_+_QUANTITY); i++)
+  {
     COUT(4) << "deleting object with id: " << *(uint32_t*)(data_+_OBJECTIDS+i*sizeof(uint32_t)) << std::endl;
+    orxout(verbose, context::packets) << "deleting object with id: " << *(uint32_t*)(data_+_OBJECTIDS+i*sizeof(uint32_t)) << endl;
     Synchronisable::deleteObject( *(uint32_t*)(data_+_OBJECTIDS+i*sizeof(uint32_t)) );
+  }

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

-                      r7801
+                      r8858
 #include <string>
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "core/ObjectList.h"
 #include "network/NetworkFunction.h"
 …
+  }
   COUT(5) << "FunctionIDs packetSize is " << packetSize << endl;
+  orxout(verbose_more, context::packets) << "FunctionIDs packetSize is " << packetSize << endl;
+}
 …
   unsigned char *functionname;
   COUT(4) << "=== processing functionids: " << endl;
+  orxout(verbose, context::packets) << "=== processing functionids: " << endl;
   std::pair<uint32_t, std::string> tempPair;
   // read the total number of classes
 …
     stringsize = *(uint32_t*)(temp+sizeof(uint32_t));
     functionname = temp+2*sizeof(uint32_t);
     COUT(3) << "processing functionid: " << networkID << " name: " << functionname << std::endl;
+    orxout(internal_info, context::packets) << "processing functionid: " << networkID << " name: " << functionname << endl;
     NetworkFunctionBase::setNetworkID((const char*)functionname, networkID);
     temp += 2*sizeof(uint32_t) + stringsize;

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

-                      r8394
+                      r8858
 #include <zlib.h>
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "util/OrxAssert.h"
 #include "core/GameMode.h"
 …
   uint32_t size = calcGamestateSize(id, mode);
   COUT(5) << "G.ST.Man: producing gamestate with id: " << id << std::endl;
+  orxout(verbose_more, context::packets) << "G.ST.Man: producing gamestate with id: " << id << endl;
   if(size==0)
     return false;
 …
   if(!data_)
+  {
     COUT(2) << "GameStateManager: could not allocate memory" << std::endl;
+    orxout(internal_warning, context::packets) << "GameStateManager: could not allocate memory" << endl;
     return false;
+  }
 …
       assert(0); // if we don't use multithreading this part shouldn't be neccessary
       // start allocate additional memory
       COUT(3) << "Gamestate: need additional memory" << std::endl;
+      orxout(internal_info, context::packets) << "Gamestate: need additional memory" << endl;
       ObjectList<Synchronisable>::iterator temp = it;
       uint32_t addsize=tempsize;
 …
   //stop write gamestate header
   COUT(5) << "Gamestate: Gamestate size: " << currentsize << std::endl;
   COUT(5) << "Gamestate: 'estimated' (and corrected) Gamestate size: " << size << std::endl;
+  orxout(verbose_more, context::packets) << "Gamestate: Gamestate size: " << currentsize << endl;
+  orxout(verbose_more, context::packets) << "Gamestate: 'estimated' (and corrected) Gamestate size: " << size << endl;
   return true;
+}
 …
 bool Gamestate::spreadData(uint8_t mode)
+{
   COUT(5) << "processing gamestate with id " << header_.getID() << endl;
+  orxout(verbose_more, context::packets) << "processing gamestate with id " << header_.getID() << endl;
   assert(data_);
   assert(!header_.isCompressed());
 …
       else
+      {
 //         COUT(4) << "not creating object of classid " << objectheader.getClassID() << endl;
+//         orxout(verbose, context::packets) << "not creating object of classid " << objectheader.getClassID() << endl;
         mem += objectheader.getDataSize() + ( objectheader.isDiffed() ? SynchronisableHeaderLight::getSize() : SynchronisableHeader::getSize() );
+      }
 …
     else
+    {
 //       COUT(4) << "updating object of classid " << objectheader.getClassID() << endl;
+//       orxout(verbose, context::packets) << "updating object of classid " << objectheader.getClassID() << endl;
       OrxVerify(s->updateData(mem, mode), "ERROR: could not update Synchronisable with Gamestate data");
+    }
 …
         if (it->objectMode_ != 0x0)
+        {
           COUT(0) << "Found object with OBJECTID_UNKNOWN on the client with objectMode != 0x0!" << std::endl;
           COUT(0) << "Possible reason for this error: Client created a synchronized object without the Server's approval." << std::endl;
           COUT(0) << "Objects class: " << it->getIdentifier()->getName() << std::endl;
+          orxout(user_error, context::packets) << "Found object with OBJECTID_UNKNOWN on the client with objectMode != 0x0!" << endl;
+          orxout(user_error, context::packets) << "Possible reason for this error: Client created a synchronized object without the Server's approval." << endl;
+          orxout(user_error, context::packets) << "Objects class: " << it->getIdentifier()->getName() << endl;
           assert(false);
+        }
 …
           if (it->getObjectID() == *it2)
+          {
             COUT(0) << "Found duplicate objectIDs on the client!" << std::endl
                     << "Are you sure you don't create a Sychnronisable objcect with 'new' \
                         that doesn't have objectMode = 0x0?" << std::endl;
+            orxout(user_error, context::packets) << "Found duplicate objectIDs on the client!" << endl
+                                                 << "Are you sure you don't create a Sychnronisable objcect with 'new' \
+                                                     that doesn't have objectMode = 0x0?" << endl;
             assert(false);
+          }
 …
   switch ( retval )
+  {
     case Z_OK: COUT(5) << "G.St.Man: compress: successfully compressed" << std::endl; break;
     case Z_MEM_ERROR: COUT(1) << "G.St.Man: compress: not enough memory available in gamestate.compress" << std::endl; return false;
     case Z_BUF_ERROR: COUT(2) << "G.St.Man: compress: not enough memory available in the buffer in gamestate.compress" << std::endl; return false;
     case Z_DATA_ERROR: COUT(2) << "G.St.Man: compress: data corrupted in gamestate.compress" << std::endl; return false;
+    case Z_OK: orxout(verbose_more, context::packets) << "G.St.Man: compress: successfully compressed" << endl; break;
+    case Z_MEM_ERROR: orxout(internal_error, context::packets) << "G.St.Man: compress: not enough memory available in gamestate.compress" << endl; return false;
+    case Z_BUF_ERROR: orxout(internal_warning, context::packets) << "G.St.Man: compress: not enough memory available in the buffer in gamestate.compress" << endl; return false;
+    case Z_DATA_ERROR: orxout(internal_warning, context::packets) << "G.St.Man: compress: data corrupted in gamestate.compress" << endl; return false;
+  }
 …
   header_.setCompSize( buffer );
   header_.setCompressed( true );
   COUT(4) << "gamestate compress datasize: " << header_.getDataSize() << " compsize: " << header_.getCompSize() << std::endl;
+  orxout(verbose, context::packets) << "gamestate compress datasize: " << header_.getDataSize() << " compsize: " << header_.getCompSize() << endl;
   return true;
+}
 …
   assert(data_);
   assert(header_.isCompressed());
   COUT(4) << "GameStateClient: uncompressing gamestate. id: " << header_.getID() << ", baseid: " << header_.getBaseID() << ", datasize: " << header_.getDataSize() << ", compsize: " << header_.getCompSize() << std::endl;
+  orxout(verbose, context::packets) << "GameStateClient: uncompressing gamestate. id: " << header_.getID() << ", baseid: " << header_.getBaseID() << ", datasize: " << header_.getDataSize() << ", compsize: " << header_.getCompSize() << endl;
   uint32_t datasize = header_.getDataSize();
   uint32_t compsize = header_.getCompSize();
 …
   switch ( retval )
+  {
     case Z_OK: COUT(5) << "successfully decompressed" << std::endl; break;
     case Z_MEM_ERROR: COUT(1) << "not enough memory available" << std::endl; return false;
     case Z_BUF_ERROR: COUT(2) << "not enough memory available in the buffer" << std::endl; return false;
     case Z_DATA_ERROR: COUT(2) << "data corrupted (zlib)" << std::endl; return false;
+    case Z_OK: orxout(verbose_more, context::packets) << "successfully decompressed" << endl; break;
+    case Z_MEM_ERROR: orxout(internal_error, context::packets) << "not enough memory available" << endl; return false;
+    case Z_BUF_ERROR: orxout(internal_warning, context::packets) << "not enough memory available in the buffer" << endl; return false;
+    case Z_DATA_ERROR: orxout(internal_warning, context::packets) << "data corrupted (zlib)" << endl; return false;
+  }
 …
   if( memcmp( origDataPtr+objectOffset, baseDataPtr+objectOffset, objectHeader.getDataSize()) == 0 )
+  {
 //     COUT(4) << "skip object " << Synchronisable::getSynchronisable(objectHeader.getObjectID())->getIdentifier()->getName() << endl;
+//     orxout(verbose, context::packets) << "skip object " << Synchronisable::getSynchronisable(objectHeader.getObjectID())->getIdentifier()->getName() << endl;
     origDataPtr += objectOffset + objectHeader.getDataSize(); // skip the whole object
     baseDataPtr += objectOffset + objectHeader.getDataSize();
 …
 inline void /*Gamestate::*/copyObject( uint8_t*& newData, uint8_t*& origData, uint8_t*& baseData, SynchronisableHeader& objectHeader, std::vector<uint32_t>::iterator& sizes )
+{
   //       COUT(4) << "docopy" << endl;
+  //       orxout(verbose, context::packets) << "docopy" << endl;
   // Just copy over the whole Object
   memcpy( newData, origData, objectHeader.getDataSize()+SynchronisableHeader::getSize() );
 …
 //   SynchronisableHeader baseHeader( baseData );
 //   baseData += baseHeader.getDataSize()+SynchronisableHeader::getSize();
   //       COUT(4) << "copy " << h.getObjectID() << endl;
   //       COUT(4) << "copy " << h.getObjectID() << ":";
+  //       orxout(verbose, context::packets) << "copy " << h.getObjectID() << endl;
+  //       orxout(verbose, context::packets) << "copy " << h.getObjectID() << ":";
   sizes += Synchronisable::getSynchronisable(objectHeader.getObjectID())->getNrOfVariables();
 //   for( unsigned int i = 0; i < Synchronisable::getSynchronisable(objectHeader.getObjectID())->getNrOfVariables(); ++i )
 //   {
 //     //         COUT(4) << " " << *sizes;
+//     //         orxout(verbose, context::packets) << " " << *sizes;
 //     ++sizes;
 //   }
     //       COUT(4) << endl;
+    //       orxout(verbose, context::packets) << endl;
+}
 …
       if( SynchronisableHeader(baseDataPtr).getDataSize()==origHeader.getDataSize() )
+      {
 //         COUT(4) << "diffing object in order: " << Synchronisable::getSynchronisable(origHeader.getObjectID())->getIdentifier()->getName() << endl;
+//         orxout(verbose, context::packets) << "diffing object in order: " << Synchronisable::getSynchronisable(origHeader.getObjectID())->getIdentifier()->getName() << endl;
         diffObject(destDataPtr, origDataPtr, baseDataPtr, origHeader, sizesIt);
         diffedObject = true;
 …
       else
+      {
 //         COUT(4) << "copy object because of different data sizes (1): " << Synchronisable::getSynchronisable(origHeader.getObjectID())->getIdentifier()->getName() << endl;
+//         orxout(verbose, context::packets) << "copy object because of different data sizes (1): " << Synchronisable::getSynchronisable(origHeader.getObjectID())->getIdentifier()->getName() << endl;
         copyObject(destDataPtr, origDataPtr, baseDataPtr, origHeader, sizesIt);
         assert(sizesIt != this->sizes_.end() || origDataPtr==origDataEnd);
 …
         if( SynchronisableHeader(baseDataPtr).getDataSize()==origHeader.getDataSize() )
+        {
 //           COUT(4) << "diffing object out of order: " << Synchronisable::getSynchronisable(origHeader.getObjectID())->getIdentifier()->getName() << endl;
+//           orxout(verbose, context::packets) << "diffing object out of order: " << Synchronisable::getSynchronisable(origHeader.getObjectID())->getIdentifier()->getName() << endl;
           diffObject(destDataPtr, origDataPtr, baseDataPtr, origHeader, sizesIt);
           diffedObject = true;
 …
         else
+        {
 //           COUT(4) << "copy object because of different data sizes (2): " << Synchronisable::getSynchronisable(origHeader.getObjectID())->getIdentifier()->getName() << endl;
+//           orxout(verbose, context::packets) << "copy object because of different data sizes (2): " << Synchronisable::getSynchronisable(origHeader.getObjectID())->getIdentifier()->getName() << endl;
           copyObject(destDataPtr, origDataPtr, baseDataPtr, origHeader, sizesIt);
           assert(sizesIt != this->sizes_.end() || origDataPtr==origDataEnd);
 …
       else
+      {
 //         COUT(4) << "copy object: " << Synchronisable::getSynchronisable(origHeader.getObjectID())->getIdentifier()->getName() << endl;
+//         orxout(verbose, context::packets) << "copy object: " << Synchronisable::getSynchronisable(origHeader.getObjectID())->getIdentifier()->getName() << endl;
         assert(baseDataPtr == oldBaseDataPtr);
         copyObject(destDataPtr, origDataPtr, baseDataPtr, origHeader, sizesIt);
 …
   //copy in the zeros
 //   std::list<obj>::iterator itt;
 //   COUT(0) << "myvector contains:";
+//   orxout() << "myvector contains:";
 //   for ( itt=dataVector_.begin() ; itt!=dataVector_.end(); itt++ )
 //     COUT(0) << " " << (*itt).objID;
 //   COUT(0) << endl;
+//     orxout() << " " << (*itt).objID;
+//   orxout() << endl;
   for(it=dataVector_.begin(); it!=dataVector_.end();){
     SynchronisableHeader oldobjectheader(origdata);
 …
     nrOfVariables += it->getNrOfVariables();
+  }
 //   COUT(0) << "allocating " << nrOfVariables << " ints" << endl;
+//   orxout() << "allocating " << nrOfVariables << " ints" << endl;
   this->sizes_.reserve(nrOfVariables);
   return size;

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

-                      r8327
+                      r8858
 #include <boost/thread/mutex.hpp>
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "Acknowledgement.h"
 #include "Chat.h"
 …
 //     peerID = NETWORK_PEER_ID_SERVER;
   Packet *p = 0;
 //   COUT(6) << "packet type: " << *(Type::Value *)&data[_PACKETID] << std::endl;
+//   orxout(verbose_ultra, context::packets) << "packet type: " << *(Type::Value *)&data[_PACKETID] << endl;
   switch( *(Type::Value *)(data + _PACKETID) )
+  {
     case Type::Acknowledgement:
 //       COUT(5) << "ack" << std::endl;
+//       orxout(verbose_more, context::packets) << "ack" << endl;
     p = new Acknowledgement( data, peerID );
       break;
     case Type::Chat:
 //       COUT(5) << "chat" << std::endl;
+//       orxout(verbose_more, context::packets) << "chat" << endl;
       p = new Chat( data, peerID );
       break;
     case Type::ClassID:
 //       COUT(5) << "classid" << std::endl;
+//       orxout(verbose_more, context::packets) << "classid" << endl;
       p = new ClassID( data, peerID );
       break;
     case Type::Gamestate:
 //       COUT(5) << "gamestate" << std::endl;
+//       orxout(verbose_more, context::packets) << "gamestate" << endl;
       p = new Gamestate( data, peerID );
       break;
     case Type::Welcome:
 //       COUT(5) << "welcome" << std::endl;
+//       orxout(verbose_more, context::packets) << "welcome" << endl;
       p = new Welcome( data, peerID );
       break;
     case Type::DeleteObjects:
 //       COUT(5) << "deleteobjects" << std::endl;
+//       orxout(verbose_more, context::packets) << "deleteobjects" << endl;
       p = new DeleteObjects( data, peerID );
       break;
     case Type::FunctionCalls:
 //       COUT(5) << "functionCalls" << std::endl;
+//       orxout(verbose_more, context::packets) << "functionCalls" << endl;
       p = new FunctionCalls( data, peerID );
       break;
     case Type::FunctionIDs:
 //       COUT(5) << "functionIDs" << std::endl;
+//       orxout(verbose_more, context::packets) << "functionIDs" << endl;
       p = new FunctionIDs( data, peerID );
       break;
 …
   packetMap_.erase(it);
   Packet::packetMapMutex_.unlock();
 //   COUT(6) << "PacketMap size: " << packetMap_.size() << std::endl;
+//   orxout(verbose_ultra, context::packets) << "PacketMap size: " << packetMap_.size() << endl;
+}

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

-                      r8706
+                      r8858
 #include <cassert>
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "network/Host.h"
 #include "network/synchronisable/Synchronisable.h"
 …
   assert(*(uint32_t *)(data_ + _ENDIANTEST ) == 0xFEDC4321);
   host->setClientID(clientID);
   COUT(3) << "Welcome set clientId: " << clientID << endl;
+  orxout(internal_info, context::packets) << "Welcome set clientId: " << clientID << endl;
   Synchronisable::setClient(true);
   delete this;

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

-                      r8706
+                      r8858
 //     assert( !header.isDiffed() );
     COUT(4) << "fabricating object with id: " << header.getObjectID() << std::endl;
+    orxout(verbose, context::network) << "fabricating object with id: " << header.getObjectID() << endl;
     Identifier* id = ClassByID(header.getClassID());
 …
+    {
         for(int i = 0; i<160; i++)
             COUT(0) << "classid: " << i << " identifier: " << ClassByID(i) << endl;
         COUT(0) << "Assertion failed: id" << std::endl;
         COUT(0) << "Possible reason for this error: Client received a synchronizable object whose class has no factory." << std::endl;
+            orxout(user_error, context::network) << "classid: " << i << " identifier: " << ClassByID(i) << endl;
+        orxout(user_error, context::network) << "Assertion failed: id" << endl;
+        orxout(user_error, context::network) << "Possible reason for this error: Client received a synchronizable object whose class has no factory." << endl;
         abort();
+    }
 …
       bo->setLevel(creator->getLevel());          // Note: this ensures that the level is known on the client for child objects of the scene (and the scene itself)
     //assert(no->classID_ == header.getClassID());
     COUT(4) << "fabricate objectID_: " << no->objectID_ << " classID_: " << no->classID_ << std::endl;
+    orxout(verbose, context::network) << "fabricate objectID_: " << no->objectID_ << " classID_: " << no->classID_ << endl;
           // update data and create object/entity...
     bool b = no->updateData(mem, mode, true);
 …
     uint8_t* oldmem = mem;
     if (this->classID_==0)
       COUT(3) << "classid 0 " << this->getIdentifier()->getName() << std::endl;
+      orxout(internal_info, context::network) << "classid 0 " << this->getIdentifier()->getName() << endl;
 #endif
 …
     // end copy header
     CCOUT(5) << "getting data from objectID_: " << objectID_ << ", classID_: " << classID_ << std::endl;
 //     COUT(4) << "objectid: " << this->objectID_ << ":";
+    orxout(verbose_more, context::network) << "getting data from objectID_: " << objectID_ << ", classID_: " << classID_ << endl;
+//     orxout(verbose, context::network) << "objectid: " << this->objectID_ << ":";
     // copy to location
     for(i=syncList_.begin(); i!=syncList_.end(); ++i)
+    {
       uint32_t varsize = (*i)->getData( mem, mode );
 //       COUT(4) << " " << varsize;
+//       orxout(verbose, context::network) << " " << varsize;
       tempsize += varsize;
       sizes.push_back(varsize);
 …
+    }
     assert(tempsize!=0);  // if this happens an empty object (with no variables) would be transmitted
 //     COUT(4) << endl;
+//     orxout(verbose, context::network) << endl;
     header.setObjectID( this->objectID_ );
 …
     if(syncList_.empty())
+    {
+      orxout(internal_warning, context::network) << "Synchronisable::updateData syncList_ is empty" << endl;
       assert(0);
-      COUT(2) << "Synchronisable::updateData syncList_ is empty" << std::endl;
       return false;
+    }
 …
+    }
     //COUT(5) << "Synchronisable: objectID_ " << syncHeader.getObjectID() << ", classID_ " << syncHeader.getClassID() << " size: " << syncHeader.getDataSize() << " synchronising data" << std::endl;
+    //orxout(verbose_more, context::network) << "Synchronisable: objectID_ " << syncHeader.getObjectID() << ", classID_ " << syncHeader.getClassID() << " size: " << syncHeader.getDataSize() << " synchronising data" << endl;
     if( !syncHeaderLight.isDiffed() )
+    {
 …
+    {
       mem += SynchronisableHeaderLight::getSize();
 //       COUT(0) << "objectID: " << this->objectID_ << endl;
+//       orxout(debug_output, context::network) << "objectID: " << this->objectID_ << endl;
       while( mem < data+syncHeaderLight.getDataSize()+SynchronisableHeaderLight::getSize() )
+      {
         VariableID varID = *(VariableID*)mem;
 //         COUT(0) << "varID: " << varID << endl;
+//         orxout(debug_output, context::network) << "varID: " << varID << endl;
         assert( varID < syncList_.size() );
         mem += sizeof(VariableID);

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

r8706	r8858
232	232	it++;
233	233	}
234		~~COUT(1~~) << "Tried to unregister not registered variable" << endl;
	234	orxout(internal_error, context::network) << "Tried to unregister not registered variable" << endl;
235	235	assert(false); //if we reach this point something went wrong:
236	236	// the variable has not been registered before

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

r7266	r8858
202	202	if ( static_cast<uint8_t>(mem) != this->varReference_ )
203	203	{ // wrong reference number, so discard the data
204		// ~~COUT(0~~) << "discharding data" << endl;
	204	// orxout(debug_output, context::network) << "discharding data" << endl;
205	205	mem += getSize( mode ); // SynchronisableVariableBidirectional::getSize returns size of variable + reference
206	206	return;

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

r6417	r8858
80	80	catch (...)
81	81	{
82		~~COUT(1) << "Error: Couln't load billboard \"" << file << '"' << std::~~endl;
	82	orxout(internal_error) << "Couldn't load billboard \"" << file << '"' << endl;
83	83	this->billboardSet_ = 0;
84	84	}
…	…
103	103	catch (...)
104	104	{
105		~~COUT(1) << "Error: Couln't load billboard \"" << file << '"' << std::~~endl;
	105	orxout(internal_error) << "Couldn't load billboard \"" << file << '"' << endl;
106	106	this->billboardSet_ = 0;
107	107	}

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

r8351	r8858
72	72	catch (...)
73	73	{
74		~~COUT(1) << "Error: Couln't load mesh \"" << meshsource << '"' << std::~~endl;
	74	orxout(internal_error) << "Couldn't load mesh \"" << meshsource << '"' << endl;
75	75	this->entity_ = 0;
76	76	}

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

r7166	r8858
78	78	catch (...)
79	79	{
80		~~COUT(1) << "Error: Couln't load particle system \"" << templateName << '"' << std::~~endl;
	80	orxout(internal_error) << "Couldn't load particle system \"" << templateName << '"' << endl;
81	81	this->particleSystem_ = 0;
82	82	}

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

r8351	r8858
62	62	if (resourceGroup.empty())
63	63	{
64		~~COUT(2) << "Warning: \"\" is not a valid resource group." << std::~~endl;
	64	orxout(internal_warning) << "\"\" is not a valid resource group." << endl;
65	65	return;
66	66	}

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

r8366	r8858
80	80	else
81	81	{
82		~~COUT(2) << "Warning: ResourceLocation '" << this->getPath() << "' does not seem to exist" << std::~~endl;
	82	orxout(internal_warning) << "ResourceLocation '" << this->getPath() << "' does not seem to exist" << endl;
83	83	return;
84	84	}
…	…
101	101	catch (const Ogre::Exception& ex)
102	102	{
103		~~COUT(1) << "Removing of a ResourceLocation failed: " << ex.what() << std::~~endl;
	103	orxout(internal_error) << "Removing of a ResourceLocation failed: " << ex.what() << endl;
104	104	}
105	105	}

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

r8079	r8858
141	141	}
142	142	else
143		~~COUT(2) << "Warning: Couldn't load compositor with name \"" << this->compositorName_ << "\"." << std::~~endl;
	143	orxout(internal_warning) << "Couldn't load compositor with name \"" << this->compositorName_ << "\"." << endl;
144	144	}
145	145	this->oldcompositorName_ = this->compositorName_;
…	…
217	217	}
218	218	else
219		~~COUT(2) << "Warning: No pass " << it->pass_ << " in technique " << it->technique_ << " in compositor \"" << this->compositorName_ << "\" or pass has no shader." << std::~~endl;
	219	orxout(internal_warning) << "No pass " << it->pass_ << " in technique " << it->technique_ << " in compositor \"" << this->compositorName_ << "\" or pass has no shader." << endl;
220	220	}
221	221	else
222		~~COUT(2) << "Warning: No technique " << it->technique_ << " in compositor \"" << this->compositorName_ << "\" or technique has no pass with shader." << std::~~endl;
	222	orxout(internal_warning) << "No technique " << it->technique_ << " in compositor \"" << this->compositorName_ << "\" or technique has no pass with shader." << endl;
223	223	}
224	224	this->parameters_.clear();

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

r8729	r8858
66	66	void MyClass::myFunction()
67	67	{
68		~~COUT(0) << "Hello World" << std::~~endl;
	68	orxout() << "Hello World" << endl;
69	69	}
70	70	@endcode

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

-                      r8729
+                      r8858
   CRC32.cc
   ExprParser.cc
-  OutputHandler.cc
   Scope.cc
   ScopedSingletonManager.cc
 …
+)
+ADD_SUBDIRECTORY(output)
 ORXONOX_ADD_LIBRARY(util
   FIND_HEADER_FILES

code/trunk/src/libraries/util/Clipboard.cc

-                      r7401
+                      r8858
 #undef min
 #undef max
 #include "Debug.h"
+#include "Output.h"
 namespace orxonox
 …
         catch (...)
+        {
             COUT(1) << "Error: Unable to copy the following text to the clipboard:" << std::endl;
             COUT(1) << "       \"" << text << '"' << std::endl;
+            orxout(user_error) << "Unable to copy the following text to the clipboard:" << endl;
+            orxout(user_error) << '"' << text << '"' << endl;
+        }
         return false;
 …
         catch (...)
+        {
             COUT(1) << "Error: Unable to retrieve text from the clipboard." << std::endl;
+            orxout(user_error) << "Unable to retrieve text from the clipboard." << endl;
+        }
         return "";

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

-                      r8729
+                      r8858
 #include <loki/TypeManip.h>
 #include "Debug.h"
+#include "Output.h"
 #include "ImplicitConversion.h"
 …
         ORX_FORCEINLINE static bool convert(ToType* /*output*/, const FromType& /*input*/)
+        {
             COUT(2) << "Could not convert value of type " << typeid(FromType).name()
                     << " to type " << typeid(ToType).name() << std::endl;
+            orxout(internal_warning) << "Could not convert value of type " << typeid(FromType).name()
+                                     << " to type " << typeid(ToType).name() << endl;
             return false;
+        }

code/trunk/src/libraries/util/Exception.cc

-                      r8410
+                      r8858
 #include <cstddef>
 #include <CEGUIExceptions.h>
 #include "Debug.h"
+#include "Output.h"
 namespace orxonox
 …
         catch (...)
+        {
             COUT(0) << "BIG WARNING: Unknown exception type encountered."
                     << "Rethrowing" << endl;
+            orxout(user_error) << "BIG WARNING: Unknown exception type encountered."
+                               << " Rethrowing" << endl;
             throw;
+        }

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

-                      r8706
+                      r8858
 #include <sstream>
 #include <string>
 #include "Debug.h"
+#include "Output.h"
 namespace orxonox
 …
     inline const T& exceptionThrowerHelper(const T& exception)
+    {
         // let the catcher decide whether to display the message below level 4
         COUT(4) << exception.getFullDescription() << std::endl;
+        // let the catcher decide whether to display the message also to the user
+        orxout(internal_error) << exception.getFullDescription() << endl;
         return exception;
+    }

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

r8351	r8858
55	55	if (!expr.getRemains().empty())
56	56	{
57		~~COUT(2) << "Warning: Expression could not be parsed to the end! Remains: '" << expr.getRemains() << '\'' << std::~~endl;
	57	orxout(user_warning) << "Expression could not be parsed to the end! Remains: '" << expr.getRemains() << '\'' << endl;
58	58	}
59	59	float result = expr.getResult();
60	60	}
61	61	else
62		~~COUT(1) << "Error: Cannot calculate expression: Parse error." << std::~~endl;
	62	orxout(user_error) << "Cannot calculate expression: Parse error." << endl;
63	63	@endcode
64	64	getRemains() returns the expression after what could be parsed. For instance

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

r7401	r8858
78	78	void myfunction(int value)
79	79	{
80		~~COUT(0) << "doubled value is " << (2 * value) << std::~~endl;
	80	orxout() << "doubled value is " << (2 * value) << endl;
81	81	}
82	82

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

-                      r8372
+                      r8858
 #include <cassert>
 #include "Debug.h"
+#include "Output.h"
 #ifndef NDEBUG
 …
 /** Run time assertion like assert(), but with an embedded message.
 @details
     The message will be printed as error with COUT(1). <br>
+    The message will be printed as error with orxout(user_error). <br>
     You can use the same magic here as you can with \ref ThrowException
     @code
 …
         if (!(condition)) \
         { \
             COUT(1) << __FILE__ << "(" << __LINE__ << "): "; \
             COUT(1) << "Assertion failed in " << __FUNCTIONNAME__ << std::endl; \
             COUT(1) << "Expression: " << #condition << std::endl; \
             COUT(1) << "Message   : " << errorMessage << std::endl; \
+            orxout(user_error) << __FILE__ << "(" << __LINE__ << "): "; \
+            orxout(user_error) << "Assertion failed in " << __FUNCTIONNAME__ << endl; \
+            orxout(user_error) << "Expression: " << #condition << endl; \
+            orxout(user_error) << "Message   : " << errorMessage << endl; \
             /* Don't use the condition again to avoid double evaluation */ \
             /* Instead, stringify the expression and negate it */ \
 …
     mode (no abort() triggered then).
 @details
     The message will be printed as error with COUT(1). <br>
+    The message will be printed as error with orxout(user_error). <br>
     You can use the same magic here as you can with \ref ThrowException
     @code
 …
         if (!(condition)) \
         { \
             COUT(1) << __FILE__ << "(" << __LINE__ << "): "; \
             COUT(1) << "Verification failed in " << __FUNCTIONNAME__ << std::endl; \
             COUT(1) << "Expression: " << #condition << std::endl; \
             COUT(1) << "Message   : " << errorMessage << std::endl; \
+            orxout(user_error) << __FILE__ << "(" << __LINE__ << "): "; \
+            orxout(user_error) << "Verification failed in " << __FUNCTIONNAME__ << endl; \
+            orxout(user_error) << "Expression: " << #condition << endl; \
+            orxout(user_error) << "Message   : " << errorMessage << endl; \
             /* Don't use the condition again to avoid double evaluation */ \
             /* Instead, stringify the expression and negate it */ \
 …
         if (!(condition)) \
         { \
             COUT(1) << __FILE__ << "(" << __LINE__ << "): "; \
             COUT(1) << "Verification failed in " << __FUNCTIONNAME__ << std::endl; \
             COUT(1) << "Expression: " << #condition << std::endl; \
             COUT(1) << "Message   : " << errorMessage << std::endl; \
+            orxout(user_error) << __FILE__ << "(" << __LINE__ << "): "; \
+            orxout(user_error) << "Verification failed in " << __FUNCTIONNAME__ << endl; \
+            orxout(user_error) << "Expression: " << #condition << endl; \
+            orxout(user_error) << "Message   : " << errorMessage << endl; \
             /* No assert() in release configuration */ \
         } \

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

r7401	r8858
60	60	#include <loki/ScopeGuard.h>
61	61
62		#include "~~Debug~~.h"
	62	#include "Output.h"
63	63
64	64	namespace orxonox
…	…
128	128	Scope()
129	129	{
	130	orxout(internal_status) << "creating scope... (" << scope << ")" << endl;
	131
130	132	try
131	133	{
…	…
148	150	throw;
149	151	}
	152
	153	orxout(internal_status) << "created scope (" << scope << ")" << endl;
150	154	}
151	155
…	…
153	157	~Scope()
154	158	{
	159	orxout(internal_status) << "destroying scope... (" << scope << ")" << endl;
	160
155	161	ScopeManager::instanceCounts_s[scope]--;
156	162
…	…
162	168	if (ScopeManager::instanceCounts_s[scope] == 0)
163	169	this->deactivateListeners();
	170
	171	orxout(internal_status) << "destroyed scope (" << scope << ")" << endl;
164	172	}
165	173
…	…
174	182	{ (*it)->deactivated(); }
175	183	catch (...)
176		{ ~~COUT(0) << "ScopeListener::deactivated() failed! This MUST NOT happen, fix it!" << std::~~endl; }
	184	{ orxout(internal_warning) << "ScopeListener::deactivated() failed! This MUST NOT happen, fix it!" << endl; }
177	185	(*(it++))->bActivated_ = false;
178	186	}

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

-                      r8706
+                      r8858
                 { singletonPtr_ = new T(); }
             catch (const InitialisationAbortedException& ex)
                 { COUT(3) << ex.getDescription() << std::endl; }
+                { orxout(internal_error) << ex.getDescription() << endl; }
             catch (...)
                 { COUT(1) << "Singleton creation failed: " << Exception::handleMessage() << std::endl; }
+                { orxout(internal_error) << "Singleton creation failed: " << Exception::handleMessage() << endl; }
+        }

code/trunk/src/libraries/util/SignalHandler.cc

-                      r8351
+                      r8858
 #include <cstdio>
 #include "Debug.h"
+#include "Output.h"
 namespace orxonox
 …
       if( SignalHandler::singletonPtr_s == 0 )
+      {
         COUT(0) << "Received signal " << sigName.c_str() << std::endl << "Can't write backtrace because SignalHandler is already destroyed" << std::endl;
+        orxout(user_error) << "Received signal " << sigName.c_str() << endl << "Can't write backtrace because SignalHandler is already destroyed" << endl;
         exit(EXIT_FAILURE);
+      }
 …
       COUT(0) << "Received signal " << sigName.c_str() << std::endl << "Try to write backtrace to file orxonox_crash.log" << std::endl;
+      orxout(user_error) << "Received signal " << sigName.c_str() << endl << "Try to write backtrace to file orxonox_crash.log" << endl;
 …
 #ifdef PR_SET_PTRACER
         if( prctl(PR_SET_PTRACER, gdbPid, 0, 0, 0) == -1 )
           COUT(0) << "could not set proper permissions for GDB to attach to process..." << endl;
+          orxout(user_error) << "could not set proper permissions for GDB to attach to process..." << endl;
 #endif
 …
         if( read( sigPipe[0], &someData, sizeof(someData) ) != sizeof(someData) )
           COUT(0) << "something went wrong :(" << std::endl;
+          orxout(user_error) << "something went wrong :(" << endl;
         if ( someData != 0x12345678 )
+        {
           COUT(0) << "something went wrong :(" << std::endl;
+          orxout(user_error) << "something went wrong :(" << endl;
+        }
 …
       if ( fwrite( bt.c_str(), 1, bt.length(), f ) != bt.length() )
+      {
         COUT(0) << "could not write " << bt.length() << " byte to " << getInstance().filename << std::endl;
+        orxout(user_error) << "could not write " << bt.length() << " byte to " << getInstance().filename << endl;
         exit(EXIT_FAILURE);
+      }
 …
 _UtilExport void __cdecl abort()
+{
+    COUT(1) << "This application has requested the Runtime to terminate it in an unusual way." << std::endl;
+    COUT(1) << "Please contact the application's support team for more information." << std::endl;
+    using namespace orxonox;
+    orxout(user_error) << "This application has requested the Runtime to terminate it in an unusual way." << endl;
+    orxout(user_error) << "Please contact the application's support team for more information." << endl;
     DebugBreak();
     exit(0x3);
 …
 _UtilExport void __cdecl _assert(const char* expression, const char* file, int line)
+{
+    COUT(1) << "Assertion failed: " << expression << ", file " << file << ", line " << line << std::endl;
+    COUT(1) << std::endl;
+    using namespace orxonox;
+    orxout(user_error) << "Assertion failed: " << expression << ", file " << file << ", line " << line << endl;
+    orxout(user_error) << endl;
     abort();
+}
 …
             bExecuting = true;
             COUT(1) << std::endl;
+            orxout(user_error) << endl;
             // if the signalhandler has already been destroyed then don't do anything
             if (SignalHandler::singletonPtr_s == 0)
+            {
                 COUT(1) << "Caught an unhandled exception" << std::endl << "Can't write backtrace because SignalHandler is already destroyed" << std::endl;
+                orxout(user_error) << "Caught an unhandled exception" << endl << "Can't write backtrace because SignalHandler is already destroyed" << endl;
                 exit(EXIT_FAILURE);
+            }
             COUT(1) << "Caught an unhandled exception" << std::endl << "Try to write backtrace to orxonox_crash.log..." << std::endl;
+            orxout(user_error) << "Caught an unhandled exception" << endl << "Try to write backtrace to orxonox_crash.log..." << endl;
             // write the crash log
 …
             time_t now = time(NULL);
             crashlog << "=======================================================" << std::endl;
+            crashlog << "=======================================================" << endl;
             crashlog << "= Time: " << std::string(ctime(&now));
             crashlog << "=======================================================" << std::endl;
             crashlog << std::endl;
+            crashlog << "=======================================================" << endl;
+            crashlog << endl;
             const std::string& error = SignalHandler::getExceptionType(pExceptionInfo);
             crashlog << error << std::endl;
             crashlog << std::endl;
+            crashlog << error << endl;
+            crashlog << endl;
             const std::string& callstack = SignalHandler::getStackTrace(pExceptionInfo);
             crashlog << "Call stack:" << std::endl;
             crashlog << callstack << std::endl;
+            crashlog << "Call stack:" << endl;
+            crashlog << callstack << endl;
             crashlog.close();
             // print the same information also to the console
             COUT(1) << std::endl;
             COUT(1) << error << std::endl;
             COUT(1) << std::endl;
             COUT(1) << "Call stack:" << std::endl;
             COUT(1) << callstack << std::endl;
+            orxout(user_error) << endl;
+            orxout(user_error) << error << endl;
+            orxout(user_error) << endl;
+            orxout(user_error) << "Call stack:" << endl;
+            orxout(user_error) << callstack << endl;
             bExecuting = false;
 …
         else
+        {
             COUT(1) << "An error occurred while writing the backtrace" << std::endl;
+            orxout(user_error) << "An error occurred while writing the backtrace" << endl;
+        }

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

r7904	r8858
100	100	void TestSingleton::testFunction() // implement testFunction
101	101	{
102		~~COUT(0) << "My value is " << this->testValue_ << std::~~endl;
	102	orxout() << "My value is " << this->testValue_ << endl;
103	103	}
104	104

code/trunk/src/libraries/util/Sleep.cc

-                      r5738
+                      r8858
 #include "Sleep.h"
 #include "Debug.h"
+#include "Output.h"
 #ifdef ORXONOX_PLATFORM_WINDOWS
 …
+    {
         //if (microseconds < 1000)
         //    COUT(2) << "Warning: Windows cannot sleep less than 1ms, ignoring" << std::endl;
+        //    orxout(internal_warning) << "Windows cannot sleep less than 1ms, ignoring" << endl;
         Sleep(microseconds / 1000);
+    }

code/trunk/src/libraries/util/StringUtils.cc

-                      r8232
+                      r8858
         for (; pos2 > 0         && (str[pos2] == ' ' || str[pos2] == '\t' || str[pos2] == '\n'); pos2--);
         return str.substr(pos1, pos2 - pos1 + 1);
+    }
+    /// Splits a given string by a delimiter and stores it in an output vector
+    void vectorize(const std::string& str, char delimiter, std::vector<std::string>* output)
+    {
+        for (size_t start = 0, end = 0; end != std::string::npos; start = end + 1)
+        {
+            end = str.find_first_of(delimiter, start);
+            output->push_back(str.substr(start, end - start));
+        }
+    }
 …
         return matrix[(rows-1)*cols + cols-1];
+    }
     /**
     @brief

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

-                      r8232
+                      r8858
 #include "UtilPrereqs.h"
 #include <string>
+#include <vector>
 namespace orxonox
 …
     _UtilExport std::string  removeTrailingWhitespaces(const std::string& str);
+    _UtilExport void         vectorize(const std::string& str, char delimiter, std::vector<std::string>* output);
     _UtilExport size_t       getNextQuote(const std::string& str, size_t start);
 …
     _UtilExport unsigned int getLevenshteinDistance(const std::string& str1, const std::string& str2);
     _UtilExport std::string  getTimestamp(void);
+}

code/trunk/src/libraries/util/SubString.cc

-                      r7401
+                      r8858
 #include "SubString.h"
 #include <cstdio>
 #include "Debug.h"
+#include "Output.h"
 namespace orxonox
 …
     void SubString::debug() const
+    {
         COUT(0) << "Substring-information::count=" << this->tokens_.size() << " ::";
+        orxout(debug_output) << "Substring-information::count=" << this->tokens_.size() << " ::";
         for (unsigned int i = 0; i < this->tokens_.size(); ++i)
             COUT(0) << "s" << i << "='" << this->tokens_[i].c_str() << "'::";
         COUT(0) << std::endl;
+            orxout(debug_output) << "s" << i << "='" << this->tokens_[i].c_str() << "'::";
+        orxout(debug_output) << endl;
+    }
+}

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

r8706	r8858
59	59
60	60	for (unsigned int i = 0; i < tokens.size(); ++i)
61		~~COUT(0) << i << ": " << tokens[i] << std::~~endl;
	61	orxout() << i << ": " << tokens[i] << endl;
62	62	@endcode
63	63

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

-                      r8729
+                      r8858
     class ExprParser;
     class MultiType;
-    class OutputHandler;
     class OutputListener;
+    class OutputManager;
+    class OutputStream;
     template <ScopeID::Value>
     class Scope;

code/trunk/src/modules/designtools/ScreenshotManager.cc

-                      r8415
+                      r8858
             finalImage->save(PathConfig::getInstance().getLogPathString() + "screenshot_" + getTimestamp() + this->fileExtension_);
             delete finalImage;
             COUT(3) << "Finished taking " << this->gridSize_*this->windowWidth_ << "x" << this->gridSize_*this->windowHeight_ << " pixel HD screenshot. Storing in log/." << endl;
+            orxout(user_info) << "Finished taking " << this->gridSize_*this->windowWidth_ << "x" << this->gridSize_*this->windowHeight_ << " pixel HD screenshot. Storing in log/." << endl;
+        }
         else
             COUT(1) << "There needs to be an active camera to make screenshots." << endl;
+            orxout(user_error) << "There needs to be an active camera to make screenshots." << endl;
         this->cleanup();
 …
                 this->buffer_->blitToMemory(this->finalPicturePB_->getSubVolume(subBox));
                 COUT(4) << "Created screenshot number " << nbScreenshots << " for multi grid HD screenshot." << endl;
+                orxout(internal_info) << "Created screenshot number " << nbScreenshots << " for multi grid HD screenshot." << endl;
+            }

code/trunk/src/modules/designtools/SkyboxGenerator.cc

-                      r8413
+                      r8858
             else
+            {
                 COUT(1) << "You must be in a level to generate a skybox." << endl;
+                orxout(user_error) << "You must be in a level to generate a skybox." << endl;
                 this->bGenerateSkybox_ = false;
                 return;
 …
                 Ogre::ResourceGroupManager::getSingleton().addResourceLocation(PathConfig::getInstance().getLogPathString(), "FileSystem", Resource::getDefaultResourceGroup());
                 COUT(4) << "Setting up SkyboxGenerator..." << endl;
+                orxout(internal_status) << "Setting up SkyboxGenerator..." << endl;
                 this->bSetup_ = false;
 …
                     entity->pitch(Degree((float)rotate.second));
                 COUT(4) << "Created face number " << this->faceCounter_ << "." << endl;
+                orxout(internal_info) << "Created face number " << this->faceCounter_ << "." << endl;
                 // Check whether we've generated all 6 faces.
                 if(++this->faceCounter_ >= 6)
 …
                 CommandExecutor::execute("pause");
                 COUT(3) << "Skybox with face size " << this->size_ << "x" << this->size_ << " pixels created. Storing in log/." << endl;
+                orxout(user_info) << "Skybox with face size " << this->size_ << "x" << this->size_ << " pixels created. Storing in log/." << endl;
+            }
+        }

code/trunk/src/modules/docking/Dock.cc

r8729	r8858
87	87	{
88	88	if(!pTrigger->isForPlayer()) { // The PlayerTrigger is not exclusively for Pawns which means we cannot extract one.
89		~~COUT(4) << "Docking:execute PlayerTrigger was not triggered by a player.." << std::~~endl;
	89	orxout(verbose, context::docking) << "Docking:execute PlayerTrigger was not triggered by a player.." << endl;
90	90	return false;
91	91	}
…	…
94	94	else
95	95	{
96		~~COUT(4) << "Docking::execute Not a player trigger, can't extract pawn from it.." << std::~~endl;
	96	orxout(verbose, context::docking) << "Docking::execute Not a player trigger, can't extract pawn from it.." << endl;
97	97	return false;
98	98	}
99	99	if(player == NULL)
100	100	{
101		~~COUT(4) << "Docking::execute Can't retrieve PlayerInfo from Trigger. (" << trigger->getIdentifier()->getName() << ")" << std::~~endl;
	101	orxout(verbose, context::docking) << "Docking::execute Can't retrieve PlayerInfo from Trigger. (" << trigger->getIdentifier()->getName() << ")" << endl;
102	102	return false;
103	103	}
…	…
168	168	if(candidates_.find(player) == candidates_.end())
169	169	{
170		~~COUT(2) << "Dock::dock Player is not a candidate!" << std::~~endl;
	170	orxout(internal_warning, context::docking) << "Dock::dock Player is not a candidate!" << endl;
171	171	return false;
172	172	}
…	…
187	187	if(docked_.find(player) == docked_.end())
188	188	{
189		~~COUT(2) << "Dock::dockingAnimationFinished Player is not currently docked." << std::~~endl;
	189	orxout(internal_warning, context::docking) << "Dock::dockingAnimationFinished Player is not currently docked." << endl;
190	190	return false;
191	191	}
…	…
200	200	if(docked_.find(player) == docked_.end())
201	201	{
202		~~COUT(2) << "Dock::undock Player is not docked to this Dock." << std::~~endl;
	202	orxout(internal_warning, context::docking) << "Dock::undock Player is not docked to this Dock." << endl;
203	203	return false;
204	204	}
…	…
218	218
219	219	bool Dock::undockingAnimationFinished(PlayerInfo* player) {
220		~~COUT(4) << "Dock::undockingAnimationFinished executed" << std::~~endl;
	220	orxout(verbose, context::docking) << "Dock::undockingAnimationFinished executed" << endl;
221	221	return true;
222	222	}

code/trunk/src/modules/docking/DockToShip.cc

-                      r8706
+                      r8858
+    {
         RegisterObject(DockToShip);
         COUT(4) << "DockToShip instance created.." << endl;
+        orxout(verbose, context::docking) << "DockToShip instance created.." << endl;
+    }
 …
     bool DockToShip::docking(PlayerInfo* player)
+    {
         COUT(4) << "DockToShip::attach" << endl;
+        orxout(verbose, context::docking) << "DockToShip::attach" << endl;
         DockingTarget *target = DockingEffect::findTarget(this->target_);
         if (target == NULL) {
             COUT(0) << "Can't retrieve target for '" << this->target_ << "'.." << std::endl;
+            orxout(internal_warning, context::docking) << "Can't retrieve target for '" << this->target_ << "'.." << endl;
             return false;
+        }
 …
         ControllableEntity *dockTo = (ControllableEntity*) target->getParent();
         if (dockTo == NULL) {
             COUT(2) << "Parent is not a ControllableEntity.." << std::endl;
+            orxout(internal_warning, context::docking) << "Parent is not a ControllableEntity.." << endl;
             return false;
+        }
 …
     bool DockToShip::release(PlayerInfo* player)
+    {
         COUT(4) << "DockToShip::release" << endl;
+        orxout(verbose, context::docking) << "DockToShip::release" << endl;
         player->stopTemporaryControl();

code/trunk/src/modules/docking/DockingController.cc

-                      r8706
+                      r8858
         if (docking)
+        {
             COUT(4) << "DockingController::takeControl Taking over control." << std::endl;
+            orxout(verbose, context::docking) << "DockingController::takeControl Taking over control." << endl;
             this->entity_->setDestroyWhenPlayerLeft(false);
 …
     void DockingController::positionReached()
+    {
         COUT(4) << "DockingController::positionReached() called." << std::endl;
+        orxout(verbose, context::docking) << "DockingController::positionReached() called." << endl;
         assert(this->player_);

code/trunk/src/modules/docking/DockingTarget.cc

r8706	r8858
53	53	SUPER(DockingTarget, XMLPort, xmlelement, mode);
54	54
55		~~COUT(4) << "DockingTarget with name '" << this->getName() << "' created.." << std::~~endl;
	55	orxout(verbose, context::docking) << "DockingTarget with name '" << this->getName() << "' created.." << endl;
56	56	}
57	57

code/trunk/src/modules/gametypes/RaceCheckPoint.cc

-                      r8767
+                      r8858
 #include "RaceCheckPoint.h"
+#include "util/Convert.h"
 #include "core/CoreIncludes.h"
 #include "core/XMLPort.h"
 #include "util/Convert.h"
+#include "chat/ChatManager.h"
 #include "SpaceRace.h"
 …
+            {
                 const std::string& message =  "You have " + multi_cast<std::string>(this->bTimeLimit_)
+                            + " seconds to reach the check point " + multi_cast<std::string>(this->bCheckpointIndex_+1) + "\n";
+                COUT(3) << message;
+                            + " seconds to reach the check point " + multi_cast<std::string>(this->bCheckpointIndex_+1);
                 const_cast<GametypeInfo*>(gametype->getGametypeInfo())->sendAnnounceMessage(message);
+                ChatManager::message(message);
+            }
+        }

code/trunk/src/modules/gametypes/SpaceRace.cc

-                      r8767
+                      r8858
 #include "core/CoreIncludes.h"
 #include "network/Host.h"
+#include "chat/ChatManager.h"
 #include "util/Convert.h"
 #include "util/Math.h"
 …
             this->clock_.capture();
             int s = this->clock_.getSeconds();
             int ms = this->clock_.getMilliseconds()-1000*s;
+            int ms = static_cast<int>(this->clock_.getMilliseconds()-1000*s);
             const std::string& message = multi_cast<std::string>(s) + "." + multi_cast<std::string>(ms) + " seconds !!\n"
                         + "You didn't reach the check point " + multi_cast<std::string>(this->checkpointsReached_+1)
                         + " before the time limit. You lose!";
-            COUT(3) << message;
             const_cast<GametypeInfo*>(this->getGametypeInfo())->sendAnnounceMessage(message);
+            ChatManager::message(message);
+        }
         else
 …
             this->clock_.capture();
             int s = this->clock_.getSeconds();
             int ms = this->clock_.getMilliseconds()-1000*s;
+            int ms = static_cast<int>(this->clock_.getMilliseconds()-1000*s);
             const std::string& message = "You win!! You have reached the last check point after "+ multi_cast<std::string>(s)
                         + "." + multi_cast<std::string>(ms) + " seconds.";
-            COUT(3) << message << std::endl;
             const_cast<GametypeInfo*>(this->getGametypeInfo())->sendAnnounceMessage(message);
+            ChatManager::message(message);
+/*
             float time = this->clock_.getSecondsPrecise();
             this->scores_.insert(time);
             std::set<float>::iterator it;
             for (it=this->scores_.begin(); it!=this->scores_.end(); it++)
+            COUT(3) <<  multi_cast<std::string>(*it) << std::endl;
+                orxout(level::message) << multi_cast<std::string>(*it) << endl;
+*/
+        }
+    }
 …
         std::string message("The match has started! Reach the check points as quickly as possible!");
-        COUT(3) << message << std::endl;
         const_cast<GametypeInfo*>(this->getGametypeInfo())->sendAnnounceMessage(message);
+        ChatManager::message(message);
+    }
 …
         this->clock_.capture();
         int s = this->clock_.getSeconds();
         int ms = this->clock_.getMilliseconds()-1000*s;
+        int ms = static_cast<int>(this->clock_.getMilliseconds()-1000*s);
         const std::string& message = "Checkpoint " + multi_cast<std::string>(this->getCheckpointsReached())
                         + " reached after " + multi_cast<std::string>(s) + "." + multi_cast<std::string>(ms)
+                        + " seconds.\n";
+        COUT(3) << message;
+                        + " seconds.";
         const_cast<GametypeInfo*>(this->getGametypeInfo())->sendAnnounceMessage(message);
+        ChatManager::message(message);
+    }

code/trunk/src/modules/notifications/NotificationDispatcher.cc

-                      r8706
+                      r8858
             return false;
         COUT(4) << "NotificationDispatcher (&" << this << ") triggered." << std::endl;
+        orxout(verbose, context::notifications) << "NotificationDispatcher (&" << this << ") triggered." << endl;
         PlayerTrigger* pTrigger = orxonox_cast<PlayerTrigger*>(trigger);
 …
         if(player == NULL)
+        {
             COUT(4) << "The NotificationDispatcher was triggered by an entity other than a Pawn. (" << trigger->getIdentifier()->getName() << ")" << std::endl;
+            orxout(verbose, context::notifications) << "The NotificationDispatcher was triggered by an entity other than a Pawn. (" << trigger->getIdentifier()->getName() << ")" << endl;
             return false;
+        }

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

-                      r8706
+                      r8858
         RegisterRootObject(NotificationManager);
         COUT(3) << "NotificatioManager created." << std::endl;
+        orxout(internal_info, context::notifications) << "NotificatioManager created." << endl;
+    }
 …
         this->allNotificationsList_.clear();
         COUT(3) << "NotificationManager destroyed." << std::endl;
+        orxout(internal_info, context::notifications) << "NotificationManager destroyed." << endl;
+    }
 …
         if(commandExecuted)
             COUT(3) << "Notification command \"" << NotificationListener::command2Str(command) << "\" executed." << endl;
+            orxout(internal_info, context::notifications) << "Notification command \"" << NotificationListener::command2Str(command) << "\" executed." << endl;
         return commandExecuted;
 …
+        }
         COUT(4) << "Notification (&" << notification << ") registered with the NotificationManager." << std::endl;
+        orxout(verbose, context::notifications) << "Notification (&" << notification << ") registered with the NotificationManager." << endl;
         return true;
 …
         this->removeNotification(notification, *(this->notificationLists_.find(queue->getName())->second));
         COUT(4) << "Notification (&" << notification << ") unregistered with the NotificationManager from NotificationQueue " << queue->getName() << "." << std::endl;
+        orxout(verbose, context::notifications) << "Notification (&" << notification << ") unregistered with the NotificationManager from NotificationQueue " << queue->getName() << "." << endl;
+    }
 …
         queue->update(); // Update the queue.
         COUT(4) << "NotificationQueue '" << queue->getName() << "' registered with the NotificationManager." << std::endl;
+        orxout(verbose, context::notifications) << "NotificationQueue '" << queue->getName() << "' registered with the NotificationManager." << endl;
         return true;
+    }
 …
         this->notificationLists_.erase(queue->getName());
         COUT(4) << "NotificationQueue '" << queue->getName() << "' unregistered with the NotificationManager." << std::endl;
+        orxout(verbose, context::notifications) << "NotificationQueue '" << queue->getName() << "' unregistered with the NotificationManager." << endl;
+    }

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

r8706	r8858
131	131	{
132	132	this->registered_ = false;
133		~~COUT(1) << "Error: NotificationQueue '" << this->getName() << "' could not be registered." << std::~~endl;
	133	orxout(internal_error, context::notifications) << "NotificationQueue '" << this->getName() << "' could not be registered." << endl;
134	134	return;
135	135	}
136	136
137		~~COUT(3) << "NotificationQueue '" << this->getName() << "' created." << std::~~endl;
	137	orxout(internal_info, context::notifications) << "NotificationQueue '" << this->getName() << "' created." << endl;
138	138	}
139	139
…	…
215	215	delete notifications;
216	216
217		~~COUT(4) << "NotificationQueue '" << this->getName() << "' updated." << std::~~endl;
	217	orxout(verbose, context::notifications) << "NotificationQueue '" << this->getName() << "' updated." << endl;
218	218	}
219	219
…	…
232	232	this->push(notification, time);
233	233
234		~~COUT(4) << "NotificationQueue '" << this->getName() << "' updated. A new Notification has been added." << std::~~endl;
	234	orxout(verbose, context::notifications) << "NotificationQueue '" << this->getName() << "' updated. A new Notification has been added." << endl;
235	235	}
236	236
…	…
265	265	this->notificationPushed(notification);
266	266
267		~~COUT(5~~) << "Notification \"" << notification->getMessage() << "\" pushed to NotificationQueue '" << this->getName() << "'" << endl;
268		~~COUT(3~~) << "NotificationQueue \"" << this->getName() << "\": " << notification->getMessage() << endl;
	267	orxout(verbose_more, context::notifications) << "Notification \"" << notification->getMessage() << "\" pushed to NotificationQueue '" << this->getName() << "'" << endl;
	268	orxout(internal_info, context::notifications) << "NotificationQueue \"" << this->getName() << "\": " << notification->getMessage() << endl;
269	269	}
270	270
…	…
284	284	if(container == *it)
285	285	{
286		~~COUT(5~~) << "Notification \"" << (*it)->notification->getMessage() << "\" popped from NotificationQueue '" << this->getName() << "'" << endl;
	286	orxout(verbose_more, context::notifications) << "Notification \"" << (*it)->notification->getMessage() << "\" popped from NotificationQueue '" << this->getName() << "'" << endl;
287	287	this->ordering_.erase(it);
288	288	break;
…	…
311	311	std::vector<NotificationContainer*>::difference_type index = it - this->notifications_.begin ();
312	312
313		~~COUT(5~~) << "Notification \"" << (*it)->notification->getMessage() << "\" removed from NotificationQueue '" << this->getName() << "'" << endl;
	313	orxout(verbose_more, context::notifications) << "Notification \"" << (*it)->notification->getMessage() << "\" removed from NotificationQueue '" << this->getName() << "'" << endl;
314	314
315	315	this->ordering_.erase(containerIterator);
…	…
333	333	void NotificationQueue::clear(bool noGraphics)
334	334	{
335		~~COUT(4~~) << "Clearing NotificationQueue " << this->getName() << "." << endl;
	335	orxout(verbose, context::notifications) << "Clearing NotificationQueue " << this->getName() << "." << endl;
336	336	this->ordering_.clear();
337	337	// Delete all NotificationContainers in the list.
…	…
367	367	if(size == 0)
368	368	{
369		~~COUT(2~~) << "Trying to set maximal size of NotificationQueue '" << this->getName() << "' to 0. Ignoring..." << endl;
	369	orxout(internal_warning, context::notifications) << "Trying to set maximal size of NotificationQueue '" << this->getName() << "' to 0. Ignoring..." << endl;
370	370	return;
371	371	}
…	…
398	398	if(time != NotificationQueue::INF && time <= 0)
399	399	{
400		~~COUT(2~~) << "Trying to set display time of NotificationQueue '" << this->getName() << "' to non-positive value. Ignoring..." << endl;
	400	orxout(internal_warning, context::notifications) << "Trying to set display time of NotificationQueue '" << this->getName() << "' to non-positive value. Ignoring..." << endl;
401	401	}
402	402

code/trunk/src/modules/notifications/NotificationQueueCEGUI.cc

r8729	r8858
143	143	if(size.x < 0.0 \|\| size.x > 1.0 \|\| size.z < 0.0 \|\| size.z > 1.0)
144	144	{
145		~~COUT(2~~) << "The display size of the NotificationQueueCEGUI " << this->getName() << " was trying to be set, but the relative size was not in [0,1]. Aborting..." << endl;
	145	orxout(internal_warning, context::notifications) << "The display size of the NotificationQueueCEGUI " << this->getName() << " was trying to be set, but the relative size was not in [0,1]. Aborting..." << endl;
146	146	return;
147	147	}
…	…
183	183	if(position.x < 0.0 \|\| position.x > 1.0 \|\| position.z < 0.0 \|\| position.z > 1.0)
184	184	{
185		~~COUT(2~~) << "The position the NotificationQueueCEGUI " << this->getName() << " was trying to be set, but the relative position was not in [0,1]. Aborting..." << endl;
	185	orxout(internal_warning, context::notifications) << "The position the NotificationQueueCEGUI " << this->getName() << " was trying to be set, but the relative position was not in [0,1]. Aborting..." << endl;
186	186	return;
187	187	}

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

r8397	r8858
216	216	else
217	217	{
218		~~COUT(2) << "Wrong mode '" << mode << "' in ForceField. Setting to 'tube'." << std::~~endl;
	218	orxout(internal_warning) << "Wrong mode '" << mode << "' in ForceField. Setting to 'tube'." << endl;
219	219	this->mode_ = forceFieldMode::tube;
220	220	}

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

r7401	r8858
73	73	{
74	74	float distance = this->getPosition().distance( activeCamera->getWorldPosition() );
75		// ~~COUT(2) << distance << std::~~endl;
	75	// orxout(internal_warning) << distance << endl;
76	76	float planetRadius = this->getScale();
77	77

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

-                      r8706
+                      r8858
             return false;
         COUT(4) << "Script (&" << this << ") triggered." << std::endl;
+        orxout(verbose, context::misc::script) << "Script (&" << this << ") triggered." << endl;
         PlayerTrigger* pTrigger = orxonox_cast<PlayerTrigger*>(trigger);
 …
         if(player == NULL)  //TODO: Will this ever happen? If not, change in NotificationDispatcher as well.
+        {
             COUT(4) << "The Script was triggered by an entity other than a Pawn. (" << trigger->getIdentifier()->getName() << ")" << std::endl;
+            orxout(internal_warning) << "The Script was triggered by an entity other than a Pawn. (" << trigger->getIdentifier()->getName() << ")" << endl;
             return false;
+        }
 …
         else
+        {
             COUT(2) << "Invalid mode '" << mode << "' in Script object. Setting to 'normal'." << std::endl;
+            orxout(internal_warning) << "Invalid mode '" << mode << "' in Script object. Setting to 'normal'." << endl;
             this->setMode(ScriptMode::normal);
             this->modeStr_ = Script::NORMAL;
 …
         else
+        {
             COUT(2) << "Invalid times '" << times << "' in Script. Setting to infinity." << std::endl;
+            orxout(internal_warning) << "Invalid times '" << times << "' in Script. Setting to infinity." << endl;
             this->times_ = Script::INF;
             this->remainingExecutions_ = Script::INF;

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

r8767	r8858
215	215	distance = this->computeDistance(currentPawn);
216	216	humanItem = this->isHumanPlayer(currentPawn);
217		~~COUT(5) << "Distance:" << distance << std::~~endl; // message for debugging
	217	// orxout() << "Distance:" << distance << endl; // message for debugging
218	218	if(distance > this->warnDistance_ && distance < this->maxDistance_) // Display warning
219	219	{
…	…
231	231	if( humanItem )
232	232	{
233		~~COUT(5) << "Health should be decreasing!" << std::~~endl;
	233	// orxout() << "Health should be decreasing!" << endl;
234	234	this->displayWarning("You are out of the area now!");
235	235	}

code/trunk/src/modules/objects/collisionshapes/BoxCollisionShape.cc

r8706	r8858
93	93	if(!this->hasUniformScaling())
94	94	{
95		~~CCOUT(1) << "Error~~: Non-uniform scaling is not yet supported." << endl;
	95	orxout(internal_error) << "BoxCollisionShape: Non-uniform scaling is not yet supported." << endl;
96	96	return;
97	97	}

code/trunk/src/modules/objects/collisionshapes/ConeCollisionShape.cc

r8706	r8858
92	92	if(!this->hasUniformScaling())
93	93	{
94		~~CCOUT(1) << "Error~~: Non-uniform scaling is not yet supported." << endl;
	94	orxout(internal_error) << "ConeCollisionShape: Non-uniform scaling is not yet supported." << endl;
95	95	return;
96	96	}

code/trunk/src/modules/objects/collisionshapes/PlaneCollisionShape.cc

r8706	r8858
92	92	if(!this->hasUniformScaling())
93	93	{
94		~~CCOUT(1) << "Error~~: Non-uniform scaling is not yet supported." << endl;
	94	orxout(internal_error) << "PlaneCollisionShape: Non-uniform scaling is not yet supported." << endl;
95	95	return;
96	96	}

code/trunk/src/modules/objects/collisionshapes/SphereCollisionShape.cc

r8706	r8858
89	89	if(!this->hasUniformScaling())
90	90	{
91		~~CCOUT(1) << "Error~~: Non-uniform scaling is not yet supported." << endl;
	91	orxout(internal_error) << "SphereCollisionShape: Non-uniform scaling is not yet supported." << endl;
92	92	return;
93	93	}

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

r8729	r8858
63	63	if (this->bActive_)
64	64	{
65		~~COUT(2) << "Warning: Detected Event loop in EventFilter \"" << this->getName() << '"' << std::~~endl;
	65	orxout(internal_warning, context::events) << "Detected Event loop in EventFilter \"" << this->getName() << '"' << endl;
66	66	return;
67	67	}

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

-                      r8729
+                      r8858
         if (this->bActive_)
+        {
             COUT(2) << "Warning: Detected Event loop in EventListener \"" << this->getName() << '"' << std::endl;
+            orxout(internal_warning, context::events) << "Detected Event loop in EventListener \"" << this->getName() << '"' << endl;
             return;
+        }
         COUT(4) << "EventListener, processing event: originator: " << event.originator_->getIdentifier()->getName() << " (&" << event.originator_ << ")" << ", activate: " << event.activate_ << ", name: " << event.name_ << std::endl;
+        orxout(verbose, context::events) << "EventListener, processing event: originator: " << event.originator_->getIdentifier()->getName() << " (&" << event.originator_ << ")" << ", activate: " << event.activate_ << ", name: " << event.name_ << endl;
         this->bActive_ = true;

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

r6417	r8858
60	60	if (this->bActive_)
61	61	{
62		~~COUT(2) << "Warning: Detected Event loop in EventTarget \"" << this->getName() << '"' << std::~~endl;
	62	orxout(internal_warning, context::events) << "Detected Event loop in EventTarget \"" << this->getName() << '"' << endl;
63	63	return;
64	64	}

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

r8706	r8858
247	247	this->setBeaconModeDirect(distanceMultiTriggerBeaconMode::exclude);
248	248	else
249		~~COUT(1~~) << "Invalid beacon mode in DistanceMultiTrigger." << endl;
	249	orxout(internal_error, context::triggers) << "Invalid beacon mode in DistanceMultiTrigger." << endl;
250	250	}
251	251

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

r8706	r8858
108	108	if (targetId == NULL)
109	109	{
110		~~COUT(1) << "Error: \"" << targetStr << "\" is not a valid class name to include in ClassTreeMask (in " << this->getName() << ", class " << this->getIdentifier()->getName() << ')' << std::~~endl;
	110	orxout(internal_error, context::triggers) << "\"" << targetStr << "\" is not a valid class name to include in ClassTreeMask (in " << this->getName() << ", class " << this->getIdentifier()->getName() << ')' << endl;
111	111	return;
112	112	}
…	…
209	209	this->setTriggeringPawn(pawn);
210	210	else
211		~~CCOUT(2~~) << "Pawn was NULL." << endl;
	211	orxout(internal_warning, context::triggers) << "Pawn was NULL." << endl;
212	212	}
213	213
…	…
270	270	this->setBeaconModeDirect(distanceTriggerBeaconMode::exclude);
271	271	else
272		~~COUT(1~~) << "Invalid beacon mode in DistanceTrigger." << endl;
	272	orxout(internal_error, context::triggers) << "Invalid beacon mode in DistanceTrigger." << endl;
273	273	}
274	274

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

r8706	r8858
72	72	MultiTrigger::~MultiTrigger()
73	73	{
74		~~COUT(4) << "Destroying MultiTrigger &" << this << ". " << this->stateQueue_.size() << " states still in queue. Deleting." << std::~~endl;
	74	orxout(verbose, context::triggers) << "Destroying MultiTrigger &" << this << ". " << this->stateQueue_.size() << " states still in queue. Deleting." << endl;
75	75	while(this->stateQueue_.size() > 0)
76	76	{
…	…
94	94	XMLPortParamLoadOnly(MultiTrigger, "target", addTarget, xmlelement, mode).defaultValues("Pawn"); //TODO: Remove load only
95	95
96		~~COUT(4) << "MultiTrigger '" << this->getName() << "' (&" << this << ") created." << std::~~endl;
	96	orxout(verbose, context::triggers) << "MultiTrigger '" << this->getName() << "' (&" << this << ") created." << endl;
97	97	}
98	98
…	…
132	132	if(state == NULL)
133	133	{
134		~~COUT(1) << "In MultiTrigger '" << this->getName() << "' (&" << this << "), Error: State of new states queue was NULL. State ignored." << std::~~endl;
	134	orxout(internal_error, context::triggers) << "In MultiTrigger '" << this->getName() << "' (&" << this << "), Error: State of new states queue was NULL. State ignored." << endl;
135	135	queue->pop();
136	136	continue;
…	…
241	241	// Print some debug output if the state has changed.
242	242	if(state->originator != NULL)
243		COUT(4) << "MultiTrigger '" << this->getName() << "' (&" << this << ") changed state. originator: " << state->originator->getIdentifier()->getName() << " (&" << state->originator << "), active: " << bActive << ", triggered: " << state->bTriggered << "." << std::endl;
	243	orxout(verbose, context::triggers) << "MultiTrigger '" << this->getName() << "' (&" << this << ") changed state. originator: " << state->originator->getIdentifier()->getName() << " (&" << state->originator << "), active: " << bActive << ", triggered: " << state->bTriggered << "." << endl;
244	244	else
245		~~COUT(4) << "MultiTrigger '" << this->getName() << "' (&" << this << ") changed state. originator: NULL, active: " << bActive << ", triggered: " << state->bTriggered << "." << std::~~endl;
	245	orxout(verbose, context::triggers) << "MultiTrigger '" << this->getName() << "' (&" << this << ") changed state. originator: NULL, active: " << bActive << ", triggered: " << state->bTriggered << "." << endl;
246	246
247	247	// If the MultiTrigger has a parent trigger, that is itself a MultiTrigger, it needs to call a method to notify him, that its activity has changed.
…	…
254	254	{
255	255	this->BaseObject::setActive(false);
256		~~COUT(4) << "MultiTrigger '" << this->getName() << "' (&" << this << ") ran out of activations. Setting it to inactive." << std::~~endl;
	256	orxout(verbose, context::triggers) << "MultiTrigger '" << this->getName() << "' (&" << this << ") ran out of activations. Setting it to inactive." << endl;
257	257	}
258	258	}
…	…
301	301	if (target == NULL)
302	302	{
303		~~COUT(1) << "Error: '" << targetStr << "' is not a valid class name to include in ClassTreeMask (in " << this->getName() << ", class " << this->getIdentifier()->getName() << ")" << std::~~endl;
	303	orxout(internal_error, context::triggers) << "'" << targetStr << "' is not a valid class name to include in ClassTreeMask (in " << this->getName() << ", class " << this->getIdentifier()->getName() << ")" << endl;
304	304	return;
305	305	}
…	…
329	329	if (target == NULL)
330	330	{
331		~~COUT(1) << "Error: '" << targetStr << "' is not a valid class name to include in ClassTreeMask (in " << this->getName() << ", class " << this->getIdentifier()->getName() << ")" << std::~~endl;
	331	orxout(internal_error, context::triggers) << "'" << targetStr << "' is not a valid class name to include in ClassTreeMask (in " << this->getName() << ", class " << this->getIdentifier()->getName() << ")" << endl;
332	332	return;
333	333	}
…	…
447	447	{
448	448	this->fireEvent(status);
449		~~COUT(4) << "MultiTrigger '" << this->getName() << "' (&" << this << "): Fired event. status: " << status << "." << std::~~endl;
	449	orxout(verbose, context::triggers) << "MultiTrigger '" << this->getName() << "' (&" << this << "): Fired event. status: " << status << "." << endl;
450	450	return;
451	451	}
…	…
453	453	MultiTriggerContainer* container = new MultiTriggerContainer(this, this, originator);
454	454	this->fireEvent(status, container);
455		COUT(4) << "MultiTrigger '" << this->getName() << "' (&" << this << "): Fired event. originator: " << originator->getIdentifier()->getName() << " (&" << originator << "), status: " << status << "." << std::endl;
	455	orxout(verbose, context::triggers) << "MultiTrigger '" << this->getName() << "' (&" << this << "): Fired event. originator: " << originator->getIdentifier()->getName() << " (&" << originator << "), status: " << status << "." << endl;
456	456	delete container;
457	457	}

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

r8706	r8858
128	128	this->setMode(TriggerMode::EventTriggerXOR);
129	129	else
130		~~COUT(2) << "Invalid mode '" << modeName << "' in TriggerBase " << this->getName() << " &(" << this << "). Leaving mode at '" << this->getModeString() << "'." << std::~~endl;
	130	orxout(internal_warning, context::triggers) << "Invalid mode '" << modeName << "' in TriggerBase " << this->getName() << " &(" << this << "). Leaving mode at '" << this->getModeString() << "'." << endl;
131	131	}
132	132

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

r7401	r8858
76	76	GUIManager::getInstance().showGUIExtra(this->guiName_, str);
77	77
78		~~COUT(4) << "Showing GUI " << this->guiName_ << std::~~endl;
	78	orxout(verbose, context::misc::gui) << "Showing GUI " << this->guiName_ << endl;
79	79	}
80	80	else
81	81	{
82	82	GUIManager::hideGUI(this->guiName_);
83		~~COUT(4) << "Hiding GUI " << this->guiName_ << std::~~endl;
	83	orxout(verbose, context::misc::gui) << "Hiding GUI " << this->guiName_ << endl;
84	84	}
85	85	}

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

-                      r8327
+                      r8858
+    }
     void ChatOverlay::incomingChat(const std::string& message, unsigned int senderID)
+    void ChatOverlay::incomingChat(const std::string& message, const std::string& /*name*/)
+    {
+        std::string text;
+        if (senderID != NETWORK_PEER_ID_UNKNOWN)
+        {
+            std::string name = "unknown";
+            PlayerInfo* player = PlayerManager::getInstance().getClient(senderID);
+            if (player)
+                name = player->getName();
+            text = name + ": " + message;
+        }
+        else
+        {
+            text = message;
+        }
+        this->messages_.push_back(multi_cast<Ogre::DisplayString>(text));
+        COUT(0) << "Chat: " << text << std::endl;
+        this->messages_.push_back(multi_cast<Ogre::DisplayString>(message));
         Timer* timer = new Timer();
 …
         this->text_->setCaption("");
         for (std::list<Ogre::DisplayString>::reverse_iterator it = this->messages_.rbegin(); it != this->messages_.rend(); ++it)
+        for (std::list<Ogre::DisplayString>::iterator it = this->messages_.begin(); it != this->messages_.end(); ++it)
+        {
             this->text_->setCaption(this->text_->getCaption() + "\n" + (*it));

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

-                      r6417
+                      r8858
 #include <OgreOverlayElement.h>
 #include "network/ChatListener.h"
+#include "chat/ChatListener.h"
 #include "overlays/OverlayText.h"
 …
         protected:
             virtual void incomingChat(const std::string& message, unsigned int senderID);
+            virtual void incomingChat(const std::string& message, const std::string& name);
             std::list<Ogre::DisplayString> messages_;

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

r8706	r8858
105	105	if ( fontPtr.isNull() )
106	106	{
107		~~COUT ( 2 ) << "Warning: HUDNavigation: Font '" << font << "' not found" << std::~~endl;
	107	orxout(internal_warning) << "HUDNavigation: Font '" << font << "' not found" << endl;
108	108	return;
109	109	}
…	…
125	125	if ( size <= 0.0f )
126	126	{
127		~~COUT ( 2 ) << "Warning: HUDNavigation: Negative font size not allowed" << std::~~endl;
	127	orxout(internal_warning) << "HUDNavigation: Negative font size not allowed" << endl;
128	128	return;
129	129	}

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

r8738	r8858
160	160	if( !wePointer )
161	161	{
162		~~CCOUT(0) << "Cannot display a non-WorldEntitiy on the radar" << std::~~endl;
	162	orxout(internal_error) << "Cannot display a non-WorldEntitiy on the radar" << endl;
163	163	assert(0);
164	164	}

code/trunk/src/modules/pickup/Pickup.cc

r7547	r8858
169	169	else
170	170	{
171		~~COUT(1) << "Invalid activationType '" << type << "' in pickup." << std::~~endl;
	171	orxout(internal_error, context::pickups) << "Invalid activationType '" << type << "' in pickup." << endl;
172	172	}
173	173	}
…	…
191	191	else
192	192	{
193		~~COUT(1) << "Invalid durationType '" << type << "' in pickup." << std::~~endl;
	193	orxout(internal_error, context::pickups) << "Invalid durationType '" << type << "' in pickup." << endl;
194	194	}
195	195	}

code/trunk/src/modules/pickup/PickupManager.cc

r8729	r8858
72	72	this->defaultRepresentation_ = new PickupRepresentation();
73	73
74		~~COUT(3) << "PickupManager created." << std::~~endl;
	74	orxout(internal_info, context::pickups) << "PickupManager created." << endl;
75	75	}
76	76
…	…
101	101	this->indexes_.clear();
102	102
103		~~COUT(3) << "PickupManager destroyed." << std::~~endl;
	103	orxout(internal_info, context::pickups) << "PickupManager destroyed." << endl;
104	104	}
105	105
…	…
126	126	this->representations_[identifier] = representation;
127	127
128		~~COUT(4) << "PickupRepresentation &" << representation << " registered with the PickupManager." << std::~~endl;
	128	orxout(verbose, context::pickups) << "PickupRepresentation &" << representation << " registered with the PickupManager." << endl;
129	129	return true;
130	130	}
…	…
151	151	this->representations_.erase(it);
152	152
153		~~COUT(4) << "PickupRepresentation &" << representation << " unregistered with the PickupManager." << std::~~endl;
	153	orxout(verbose, context::pickups) << "PickupRepresentation &" << representation << " unregistered with the PickupManager." << endl;
154	154	return true;
155	155	}
…	…
208	208	if(it == this->representations_.end()) // If there is no PickupRepresentation associated with the input PickupIdentifier.
209	209	{
210		~~COUT(4) << "PickupManager::getRepresentation() returned default representation." << std::~~endl;
	210	orxout(verbose, context::pickups) << "PickupManager::getRepresentation() returned default representation." << endl;
211	211	return this->defaultRepresentation_;
212	212	}
…	…
284	284	if(manager.pickupInventoryContainers_.find(pickup) == manager.pickupInventoryContainers_.end())
285	285	{
286		~~COUT(1) << "Error: Pickupable &(" << pickup << ") was not registered with PickupManager for the PickupInventory, when it changed used." << std::~~endl;
	286	orxout(internal_error, context::pickups) << "Pickupable &(" << pickup << ") was not registered with PickupManager for the PickupInventory, when it changed used." << endl;
287	287	return;
288	288	}

code/trunk/src/modules/pickup/PickupRepresentation.cc

-                      r8713
+                      r8858
             this->spawnerRepresentation_->setVisible(false);
         COUT(4) << "PickupRepresentation created: name: '" << this->name_ << "', description: '" << this->description_ << "', spawnerTemplate: '" << this->spawnerTemplate_ << "'." << std::endl;
+        orxout(verbose, context::pickups) << "PickupRepresentation created: name: '" << this->name_ << "', description: '" << this->description_ << "', spawnerTemplate: '" << this->spawnerTemplate_ << "'." << endl;
+    }
 …
         if(this->spawnerRepresentation_ == NULL)
+        {
             COUT(4) << "PickupRepresentation: No spawner representation found." << std::endl;
+            orxout(verbose, context::pickups) << "PickupRepresentation: No spawner representation found." << endl;
             if(this->spawnerTemplate_ == "")
+            {
                 COUT(4) << "PickupRepresentation: Spawner template is empty." << std::endl;
+                orxout(verbose, context::pickups) << "PickupRepresentation: Spawner template is empty." << endl;
                 // If neither spawnerRepresentation nor spawnerTemplate was specified
                 return this->getDefaultSpawnerRepresentation(spawner);

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

r7801	r8858
90	90	if(this->pickup_ == NULL)
91	91	{
92		~~COUT(2) << "A PickupSpawner was created without a valid Pickupable. This won't work." << std::~~endl;
	92	orxout(internal_warning, context::pickups) << "A PickupSpawner was created without a valid Pickupable. This won't work." << endl;
93	93	this->setActive(false);
94	94	}
…	…
144	144	if(this->pickup_ == NULL)
145	145	{
146		~~COUT(2) << "A PickupSpawner was created without a valid Pickupable. This won't work." << std::~~endl;
	146	orxout(internal_warning, context::pickups) << "A PickupSpawner was created without a valid Pickupable. This won't work." << endl;
147	147	this->setActive(false);
148	148	}
…	…
239	239	else
240	240	{
241		~~COUT(4) << "PickupSpawner (&" << this << ") empty, selfdestruct initialized." << std::~~endl;
	241	orxout(verbose, context::pickups) << "PickupSpawner (&" << this << ") empty, selfdestruct initialized." << endl;
242	242	this->setActive(false);
243	243	this->destroy();
…	…
264	264	if(this->pickup_ != NULL)
265	265	{
266		~~COUT(1) << "In PickupSpawner (&" << this << "): setPickupable called, with this->pickup_ already set." << std::~~endl;
	266	orxout(internal_error, context::pickups) << "In PickupSpawner (&" << this << "): setPickupable called, with this->pickup_ already set." << endl;
267	267	return;
268	268	}
269	269	if(pickup == NULL)
270	270	{
271		~~COUT(1) << "In PickupSpawner (&" << this << "): Argument of setPickupable is NULL." << std::~~endl;
	271	orxout(internal_error, context::pickups) << "In PickupSpawner (&" << this << "): Argument of setPickupable is NULL." << endl;
272	272	return;
273	273	}
…	…
298	298	if(this->isActive()) // Checks whether PickupSpawner is active.
299	299	{
300		~~COUT(4) << "PickupSpawner (&" << this << ") triggered and active." << std::~~endl;
	300	orxout(verbose, context::pickups) << "PickupSpawner (&" << this << ") triggered and active." << endl;
301	301
302	302	PickupCarrier* carrier = dynamic_cast<PickupCarrier*>(pawn);
…	…
306	306	if(!carrier->isTarget(this->pickup_))
307	307	{
308		~~COUT(4) << "PickupSpawner (&" << this << ") triggered but Pawn wasn't a target of the Pickupable." << std::~~endl;
	308	orxout(verbose, context::pickups) << "PickupSpawner (&" << this << ") triggered but Pawn wasn't a target of the Pickupable." << endl;
309	309	return;
310	310	}
…	…
335	335	if(this->spawnsRemaining_ == 0)
336	336	{
337		~~COUT(1) << "Massive Error: PickupSpawner still alive until having spawned last item." << std::~~endl;
	337	orxout(internal_error, context::pickups) << "Massive Error: PickupSpawner still alive until having spawned last item." << endl;
338	338	return NULL;
339	339	}
…	…
349	349	void PickupSpawner::respawnTimerCallback()
350	350	{
351		~~COUT(4) << "PickupSpawner (&" << this << ") reactivated." << std::~~endl;
	351	orxout(verbose, context::pickups) << "PickupSpawner (&" << this << ") reactivated." << endl;
352	352
353	353	this->setActive(true);

code/trunk/src/modules/pickup/items/DronePickup.cc

r7548	r8858
179	179	if(pawn == NULL)
180	180	{
181		~~COUT(1) << "Invalid PickupCarrier in DronePickup." << std::~~endl;
	181	orxout(internal_error, context::pickups) << "Invalid PickupCarrier in DronePickup." << endl;
182	182	}
183	183

code/trunk/src/modules/pickup/items/HealthPickup.cc

r7548	r8858
169	169	break;
170	170	default:
171		~~COUT(1) << "Invalid healthType in HealthPickup." << std::~~endl;
	171	orxout(internal_error, context::pickups) << "Invalid healthType in HealthPickup." << endl;
172	172	}
173	173
…	…
218	218	break;
219	219	default:
220		~~COUT(1) << "Invalid healthType in HealthPickup." << std::~~endl;
	220	orxout(internal_error, context::pickups) << "Invalid healthType in HealthPickup." << endl;
221	221	}
222	222
…	…
234	234	if(pawn == NULL)
235	235	{
236		~~COUT(1) << "Something went horribly wrong in Health Pickup. PickupCarrier is no Pawn." << std::~~endl;
	236	orxout(internal_error, context::pickups) << "Something went horribly wrong in Health Pickup. PickupCarrier is no Pawn." << endl;
237	237	this->Pickupable::destroy();
238	238	return;
…	…
268	268	if(pawn == NULL)
269	269	{
270		~~COUT(1) << "Invalid PickupCarrier in HealthPickup." << std::~~endl;
	270	orxout(internal_error, context::pickups) << "Invalid PickupCarrier in HealthPickup." << endl;
271	271	}
272	272
…	…
312	312	return HealthPickup::healthTypePermanent_s;
313	313	default:
314		~~COUT(1) << "Invalid healthType in HealthPickup." << std::~~endl;
	314	orxout(internal_error, context::pickups) << "Invalid healthType in HealthPickup." << endl;
315	315	return BLANKSTRING;
316	316	}
…	…
331	331	else
332	332	{
333		~~COUT(1) << "Invalid health in HealthPickup." << std::~~endl;
	333	orxout(internal_error, context::pickups) << "Invalid health in HealthPickup." << endl;
334	334	this->health_ = 0.0;
335	335	}
…	…
350	350	else
351	351	{
352		~~COUT(1) << "Invalid healthSpeed in HealthPickup." << std::~~endl;
	352	orxout(internal_error, context::pickups) << "Invalid healthSpeed in HealthPickup." << endl;
353	353	}
354	354	}
…	…
376	376	else
377	377	{
378		~~COUT(1) << "Invalid healthType in HealthPickup." << std::~~endl;
	378	orxout(internal_error, context::pickups) << "Invalid healthType in HealthPickup." << endl;
379	379	}
380	380	}

code/trunk/src/modules/pickup/items/InvisiblePickup.cc

r8220	r8858
206	206	if(pawn == NULL)
207	207	{
208		~~COUT(1) << "Invalid PickupCarrier in InvisiblePickup." << std::~~endl;
	208	orxout(internal_error, context::pickups) << "Invalid PickupCarrier in InvisiblePickup." << endl;
209	209	}
210	210	return pawn;
…	…
225	225	else
226	226	{
227		~~COUT(1) << "Invalid duration in InvisiblePickup." << std::~~endl;
	227	orxout(internal_error, context::pickups) << "Invalid duration in InvisiblePickup." << endl;
228	228	this->duration_ = 0.0f;
229	229	}

code/trunk/src/modules/pickup/items/MetaPickup.cc

r7548	r8858
232	232	}
233	233	else
234		~~COUT(2) << "Invalid metaType '" << type << "' in MetaPickup." << std::~~endl;
	234	orxout(internal_warning, context::pickups) << "Invalid metaType '" << type << "' in MetaPickup." << endl;
235	235	}
236	236

code/trunk/src/modules/pickup/items/ShieldPickup.cc

r7548	r8858
181	181	if(pawn == NULL)
182	182	{
183		~~COUT(1) << "Invalid PickupCarrier in ShieldPickup." << std::~~endl;
	183	orxout(internal_error, context::pickups) << "Invalid PickupCarrier in ShieldPickup." << endl;
184	184	}
185	185	return pawn;
…	…
220	220	else
221	221	{
222		~~COUT(1) << "Invalid duration in ShieldPickup." << std::~~endl;
	222	orxout(internal_error, context::pickups) << "Invalid duration in ShieldPickup." << endl;
223	223	this->duration_ = 0.0f;
224	224	}
…	…
239	239	else
240	240	{
241		~~COUT(1) << "Invalid Shieldhealth in ShieldPickup." << std::~~endl;
	241	orxout(internal_error, context::pickups) << "Invalid Shieldhealth in ShieldPickup." << endl;
242	242	this->shieldHealth_=0;
243	243	}
…	…
258	258	else
259	259	{
260		~~COUT(1) << "Invalid Absorption in ShieldPickup." << std::~~endl;
	260	orxout(internal_error, context::pickups) << "Invalid Absorption in ShieldPickup." << endl;
261	261	this->shieldAbsorption_=0;
262	262	}

code/trunk/src/modules/pickup/items/ShrinkPickup.h

-                      r8713
+                      r8858
             */
             inline void setShrinkFactor(float factor)
                 { if(factor <= 1.0f) { COUT(2) << "Invalid shrinking factor in ShrinkPickup. Ignoring.." << endl; return; } this->shrinkFactor_ = factor; }
+                { if(factor <= 1.0f) { orxout(internal_warning, context::pickups) << "Invalid shrinking factor in ShrinkPickup. Ignoring.." << endl; return; } this->shrinkFactor_ = factor; }
             /**
             @brief Get the duration for which the ship remains shrunken.
 …
             */
             inline void setDuration(float duration)
                 { if(duration < 0.0f) { COUT(2) << "Invalid duration in ShrinkPickup. Ignoring.." << endl; return; } this->duration_ = duration; }
+                { if(duration < 0.0f) { orxout(internal_warning, context::pickups) << "Invalid duration in ShrinkPickup. Ignoring.." << endl; return; } this->duration_ = duration; }
             /**
             @brief Get the shrink speed.
 …
             */
             inline void setShrinkDuration(float speed)
                 { if(speed <= 0.0f) { COUT(2) << "Invalid shrink duration in ShrinkPickup. Ignoring.." << endl; return; } this->shrinkDuration_ = speed; }
+                { if(speed <= 0.0f) { orxout(internal_warning, context::pickups) << "Invalid shrink duration in ShrinkPickup. Ignoring.." << endl; return; } this->shrinkDuration_ = speed; }
         protected:

code/trunk/src/modules/pickup/items/SpeedPickup.cc

r8727	r8858
180	180	if(ship == NULL)
181	181	{
182		~~COUT(1) << "Invalid PickupCarrier in SpeedPickup." << std::~~endl;
	182	orxout(internal_error, context::pickups) << "Invalid PickupCarrier in SpeedPickup." << endl;
183	183	}
184	184
…	…
221	221	else
222	222	{
223		~~COUT(1) << "Invalid duration in SpeedPickup." << std::~~endl;
	223	orxout(internal_error, context::pickups) << "Invalid duration in SpeedPickup." << endl;
224	224	this->duration_ = 0.0f;
225	225	}
…	…
240	240	else
241	241	{
242		~~COUT(1) << "Invalid speedAdd in SpeedPickup." << std::~~endl;
	242	orxout(internal_error, context::pickups) << "Invalid speedAdd in SpeedPickup." << endl;
243	243	this->speedAdd_ = 0.0f;
244	244	}
…	…
259	259	else
260	260	{
261		~~COUT(1) << "Invalid speedMultiply in SpeedPickup." << std::~~endl;
	261	orxout(internal_error, context::pickups) << "Invalid speedMultiply in SpeedPickup." << endl;
262	262	this->speedMultiply_ = 1.0f;
263	263	}

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

r8108	r8858
162	162	else // If no centerpoint was specified, an error is thrown and the level is exited.
163	163	{
164		~~COUT(1) << "Error: No Centerpoint specified." << std::~~endl;
	164	orxout(internal_error) << "Pong: No Centerpoint specified." << endl;
165	165	GSLevel::startMainMenu();
166	166	return;

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

r7552	r8858
71	71	XMLPortObject(GlobalQuest, QuestEffect, "reward-effects", addRewardEffect, getRewardEffects, xmlelement, mode);
72	72
73		~~COUT(4) << "New GlobalQuest {" << this->getId() << "} created." << std::~~endl;
	73	orxout(verbose, context::quests) << "New GlobalQuest {" << this->getId() << "} created." << endl;
74	74	}
75	75
…	…
87	87	if(!this->isFailable(player)) // Check whether the Quest can be failed.
88	88	{
89		~~COUT(4) << "A non-completable quest was trying to be failed." << std::~~endl;
	89	orxout(verbose, context::quests) << "A non-completable quest was trying to be failed." << endl;
90	90	return false;
91	91	}
…	…
114	114	if(!this->isCompletable(player)) // Check whether the Quest can be completed.
115	115	{
116		~~COUT(4) << "A non-completable quest was trying to be completed." << std::~~endl;
	116	orxout(verbose, context::quests) << "A non-completable quest was trying to be completed." << endl;
117	117	return false;
118	118	}
…	…
227	227	this->rewards_.push_back(effect); // Add the QuestEffect to the list.
228	228
229		~~COUT(4) << "Reward effect was added to Quest {" << this->getId() << "}." << std::~~endl;
	229	orxout(verbose, context::quests) << "Reward effect was added to Quest {" << this->getId() << "}." << endl;
230	230	return true;
231	231	}

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

r7552	r8858
69	69	SUPER(LocalQuest, XMLPort, xmlelement, mode);
70	70
71		~~COUT(4) << "New LocalQuest {" << this->getId() << "} created." << std::~~endl;
	71	orxout(verbose, context::quests) << "New LocalQuest {" << this->getId() << "} created." << endl;
72	72	}
73	73
…	…
85	85	if(!this->isFailable(player)) // Checks whether the quest can be failed.
86	86	{
87		~~COUT(4) << "A non-failable quest was trying to be failed." << std::~~endl;
	87	orxout(verbose, context::quests) << "A non-failable quest was trying to be failed." << endl;
88	88	return false;
89	89	}
…	…
108	108	if(!this->isCompletable(player)) // Checks whether the Quest can be completed.
109	109	{
110		~~COUT(4) << "A non-completable quest was trying to be completed." << std::~~endl;
	110	orxout(verbose, context::quests) << "A non-completable quest was trying to be completed." << endl;
111	111	return false;
112	112	}

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

-                      r7552
+                      r8858
         this->parentQuest_ = quest;
         COUT(4) << "Parent Quest {" << quest->getId() << "} was added to Quest {" << this->getId() << "}." << std::endl;
+        orxout(verbose, context::quests) << "Parent Quest {" << quest->getId() << "} was added to Quest {" << this->getId() << "}." << endl;
         return true;
+    }
 …
         this->subQuests_.push_back(quest); // Adds the Quest to the end of the list of sub-quests.
         COUT(4) << "Sub Quest {" << quest->getId() << "} was added to Quest {" << this->getId() << "}." << std::endl;
+        orxout(verbose, context::quests) << "Sub Quest {" << quest->getId() << "} was added to Quest {" << this->getId() << "}." << endl;
         return true;
+    }
 …
         this->hints_.push_back(hint); // Adds the QuestHint to the end of the list of QuestHints.
         COUT(4) << "QuestHint {" << hint->getId() << "} was added to Quest {" << this->getId() << "}." << std::endl;
+        orxout(verbose, context::quests) << "QuestHint {" << hint->getId() << "} was added to Quest {" << this->getId() << "}." << endl;
         return true;
+    }
 …
         this->failEffects_.push_back(effect); // Adds the QuestEffect to the end of the list of fail QuestEffects.
         COUT(4) << "A FailEffect was added to Quest {" << this->getId() << "}." << std::endl;
+        orxout(verbose, context::quests) << "A FailEffect was added to Quest {" << this->getId() << "}." << endl;
         return true;
+    }
 …
         this->completeEffects_.push_back(effect); // Adds the QuestEffect to the end of the list of complete QuestEffects.
         COUT(4) << "A CompleteEffect was added to Quest {" << this->getId() << "}." << std::endl;
+        orxout(verbose, context::quests) << "A CompleteEffect was added to Quest {" << this->getId() << "}." << endl;
         return true;
+    }
 …
         this->setStatus(player, QuestStatus::Failed);
         COUT(4) << "Quest {" << this->getId() << "} is failed for player: " << player << " ." <<std::endl;
+        orxout(verbose, context::quests) << "Quest {" << this->getId() << "} is failed for player: " << player << " ." << endl;
         this->getDescription()->sendFailQuestNotification(player);
 …
         this->setStatus(player, QuestStatus::Completed);
         COUT(4) << "Quest {" << this->getId() << "} is completed for player: " << player << " ." <<std::endl;
+        orxout(verbose, context::quests) << "Quest {" << this->getId() << "} is completed for player: " << player << " ." << endl;
         this->getDescription()->sendCompleteQuestNotification(player);
 …
         if(!this->isStartable(player)) // Checks whether the quest can be started.
+        {
             COUT(4) << "A non-startable quest was trying to be started." << std::endl;
+            orxout(verbose, context::quests) << "A non-startable quest was trying to be started." << endl;
             return false;
+        }
         COUT(4) << "Quest {" << this->getId() << "} is started for player: " << player << " ." <<std::endl;
+        orxout(verbose, context::quests) << "Quest {" << this->getId() << "} is started for player: " << player << " ." << endl;
         QuestListener::advertiseStatusChange(this->listeners_, "start"); // Tells the QuestListeners, that the status has changed to active.

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

r8706	r8858
79	79	XMLPortParam(QuestDescription, "completeMessage", setCompleteMessage, getCompleteMessage, xmlelement, mode);
80	80
81		~~COUT(4) << "New QuestDescription with title '" << this->getTitle() << "' created." << std::~~endl;
	81	orxout(verbose, context::quests) << "New QuestDescription with title '" << this->getTitle() << "' created." << endl;
82	82	}
83	83
…	…
109	109	else
110	110	{
111		~~COUT(2) << "Bad input in notificationHelper, this should not be happening!" << std::~~endl;
	111	orxout(internal_warning, context::quests) << "Bad input in notificationHelper, this should not be happening!" << endl;
112	112	return false;
113	113	}
…	…
115	115	else
116	116	{
117		~~COUT(2) << "Bad input in notificationHelper, this should not be happening!" << std::~~endl;
	117	orxout(internal_warning, context::quests) << "Bad input in notificationHelper, this should not be happening!" << endl;
118	118	return false;
119	119	}

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

r8351	r8858
70	70	bool temp = true;
71	71
72		~~COUT(4) << "Invoking QuestEffects on player: " << player << " ." << std::~~endl;
	72	orxout(verbose, context::quests) << "Invoking QuestEffects on player: " << player << " ." << endl;
73	73
74	74	for (std::list<QuestEffect*>::iterator effect = effects.begin(); effect != effects.end(); effect++)

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

-                      r8706
+                      r8858
         XMLPortEventSink(QuestEffectBeacon, BaseObject, "execute", execute, xmlelement, mode); //TODO: Change BaseObject to MultiTrigger as soon as MultiTrigger is the base of all triggers.
         COUT(4) << "New QuestEffectBeacon created." << std::endl;
+        orxout(verbose, context::quests) << "New QuestEffectBeacon created." << endl;
+    }
 …
         if(!(this->isActive())) // If the QuestEffectBeacon is inactive it cannot be executed.
+        {
             COUT(4) << "The QuestEffectBeacon is inactive." << std::endl;
+            orxout(verbose, context::quests) << "The QuestEffectBeacon is inactive." << endl;
             return false;
+        }
 …
         if(player == NULL)
+        {
             COUT(4) << "The QuestEffectBeacon was triggered by an entity other than a Pawn. (" << trigger->getIdentifier()->getName() << ")" << std::endl;
             return false;
+        }
         COUT(4) << "QuestEffectBeacon executed on player: " << player << " ." << std::endl;
+            orxout(verbose, context::quests) << "The QuestEffectBeacon was triggered by an entity other than a Pawn. (" << trigger->getIdentifier()->getName() << ")" << endl;
+            return false;
+        }
+        orxout(verbose, context::quests) << "QuestEffectBeacon executed on player: " << player << " ." << endl;
         bool temp = QuestEffect::invokeEffects(player, this->effects_); // Invoke the QuestEffects on the PlayerInfo.
 …
         this->effects_.push_back(effect);
         COUT(4) << "A QuestEffect was added to a QuestEffectBeacon." << std::endl;
+        orxout(verbose, context::quests) << "A QuestEffect was added to a QuestEffectBeacon." << endl;
         return true;
+    }

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

r7552	r8858
74	74	QuestManager::getInstance().registerHint(this); // Registers the QuestHint with the QuestManager.
75	75
76		~~COUT(4) << "New QuestHint {" << this->getId() << "} created." << std::~~endl;
	76	orxout(verbose, context::quests) << "New QuestHint {" << this->getId() << "} created." << endl;
77	77	}
78	78
…	…
120	120	else
121	121	{
122		~~COUT(4) << "An already active questHint was trying to get activated." << std::~~endl;
	122	orxout(verbose, context::quests) << "An already active questHint was trying to get activated." << endl;
123	123	return false;
124	124	}
125	125	}
126	126
127		~~COUT(4) << "A hint of a non-active quest was trying to get activated." << std::~~endl;
	127	orxout(verbose, context::quests) << "A hint of a non-active quest was trying to get activated." << endl;
128	128	return false;
129	129	}

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

r8079	r8858
89	89	if(id == "") // Checks whether the id is a valid id.
90	90	{
91		~~COUT(2) << "Invalid id. QuestItem id {" << id << "} could not be set." << std::~~endl;
	91	orxout(internal_warning, context::quests) << "Invalid id. QuestItem id {" << id << "} could not be set." << endl;
92	92	return;
93	93	}

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

-                      r7462
+                      r8858
             this->quest_->addListener(this); // Adds the QuestListener to the Quests list of listeners.
         COUT(4) << "QuestListener created for quest: {" << this->quest_->getId() << "} with mode '" << this->getMode() << "'." << std::endl;
+        orxout(verbose, context::quests) << "QuestListener created for quest: {" << this->quest_->getId() << "} with mode '" << this->getMode() << "'." << endl;
+    }
 …
         else
+        {
             COUT(2) << "QuestListener with invalid mode '" << mode << "' created. Mode set to 'all'." << std::endl;
+            orxout(internal_warning, context::quests) << "QuestListener with invalid mode '" << mode << "' created. Mode set to 'all'." << endl;
             this->mode_ = QuestListenerMode::All;
             return false;

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

r8729	r8858
61	61	RegisterRootObject(QuestManager);
62	62
63		~~COUT(3) << "QuestManager created." << std::~~endl;
	63	orxout(internal_info, context::quests) << "QuestManager created." << endl;
64	64	}
65	65
…	…
70	70	QuestManager::~QuestManager()
71	71	{
72		~~COUT(3) << "QuestManager destroyed." << std::~~endl;
	72	orxout(internal_info, context::quests) << "QuestManager destroyed." << endl;
73	73	}
74	74
…	…
103	103	{
104	104	quest->setRegistered();
105		~~COUT(4) << "Quest with questId {" << quest->getId() << "} successfully inserted." << std::~~endl;
	105	orxout(verbose, context::quests) << "Quest with questId {" << quest->getId() << "} successfully inserted." << endl;
106	106	return true;
107	107	}
108	108	else
109	109	{
110		~~COUT(2) << "Quest with the same id was already present." << std::~~endl;
	110	orxout(internal_warning, context::quests) << "Quest with the same id was already present." << endl;
111	111	return false;
112	112	}
…	…
141	141	{
142	142	hint->setRegistered();
143		~~COUT(4) << "QuestHint with hintId {" << hint->getId() << "} successfully inserted." << std::~~endl;
	143	orxout(verbose, context::quests) << "QuestHint with hintId {" << hint->getId() << "} successfully inserted." << endl;
144	144	return true;
145	145	}
146	146	else
147	147	{
148		~~COUT(2) << "QuestHint with the same id was already present." << std::~~endl;
	148	orxout(internal_warning, context::quests) << "QuestHint with the same id was already present." << endl;
149	149	return false;
150	150	}
…	…
183	183	{
184	184	quest = NULL;
185		~~COUT(2) << "The quest with id {" << questId << "} is nowhere to be found." << std::~~endl;
	185	orxout(internal_warning, context::quests) << "The quest with id {" << questId << "} is nowhere to be found." << endl;
186	186	}
187	187
…	…
212	212	{
213	213	hint = NULL;
214		~~COUT(2) << "The hint with id {" << hintId << "} is nowhere to be found." << std::~~endl;
	214	orxout(internal_warning, context::quests) << "The hint with id {" << hintId << "} is nowhere to be found." << endl;
215	215	}
216	216
…	…
431	431	if(player == NULL)
432	432	{
433		~~COUT(1) << "Error: GUIOverlay with name '" << guiName << "' has no player." << std::~~endl;
	433	orxout(internal_error, context::quests) << "GUIOverlay with name '" << guiName << "' has no player." << endl;
434	434	return NULL;
435	435	}

code/trunk/src/modules/questsystem/effects/AddQuest.cc

-                      r7552
+                      r8858
         SUPER(AddQuest, XMLPort, xmlelement, mode);
         COUT(4) << "New AddQuest, with target Quest {" << this->getQuestId() << "}, created." << std::endl;
+        orxout(verbose, context::quests) << "New AddQuest, with target Quest {" << this->getQuestId() << "}, created." << endl;
+    }
 …
         assert(player);
         COUT(5) << "AddQuest on player: " << player << " ." << std::endl;
+        orxout(verbose_more, context::quests) << "AddQuest on player: " << player << " ." << endl;
         try
 …
         catch(const orxonox::Exception& ex)
+        {
             COUT(2) << ex.getFullDescription() << std::endl;
+            orxout(internal_warning, context::quests) << ex.getFullDescription() << endl;
             return false;
+        }
         COUT(4) << "Quest {" << this->getQuestId() << "} successfully added to player: " << player << " ." << std::endl;
+        orxout(verbose, context::quests) << "Quest {" << this->getQuestId() << "} successfully added to player: " << player << " ." << endl;
         return true;
+    }

code/trunk/src/modules/questsystem/effects/AddQuestHint.cc

-                      r8079
+                      r8858
         XMLPortParam(AddQuestHint, "hintId", setHintId, getHintId, xmlelement, mode);
         COUT(4) << "New AddQuestHint, with target QuestHint {" << this->getHintId() << "}, created." << std::endl;
+        orxout(verbose, context::quests) << "New AddQuestHint, with target QuestHint {" << this->getHintId() << "}, created." << endl;
+    }
 …
         if(id == "")
+        {
             COUT(2) << "Invalid id. QuestItem id {" << id << "} could not be set." << std::endl;
+            orxout(internal_warning, context::quests) << "Invalid id. QuestItem id {" << id << "} could not be set." << endl;
             return false;
+        }
 …
         assert(player);
         COUT(5) << "AddQuestHint on player: " << player << " ." << std::endl;
+        orxout(verbose_more, context::quests) << "AddQuestHint on player: " << player << " ." << endl;
         try
 …
         catch(const Exception& e)
+        {
            COUT(2) << e.getFullDescription() << std::endl;
+           orxout(internal_warning, context::quests) << e.getFullDescription() << endl;
            return false;
+        }
         COUT(4) << "QuestHint {" << this->getHintId() << "} successfully added to player: " << player << " ." << std::endl;
+        orxout(verbose, context::quests) << "QuestHint {" << this->getHintId() << "} successfully added to player: " << player << " ." << endl;
         return true;

code/trunk/src/modules/questsystem/effects/AddReward.cc

-                      r8351
+                      r8858
         XMLPortObject(AddReward, Rewardable, "", addRewardable, getRewardables, xmlelement, mode);
         COUT(4) << "New AddReward, with " << this->rewards_.size() << " Rewardables created." << std::endl;
+        orxout(verbose, context::quests) << "New AddReward, with " << this->rewards_.size() << " Rewardables created." << endl;
+    }
 …
     bool AddReward::invoke(PlayerInfo* player)
+    {
         COUT(5) << "AddReward on player: " << player << " ." << std::endl;
+        orxout(verbose_more, context::quests) << "AddReward on player: " << player << " ." << endl;
         bool temp = true;
 …
             temp = temp && (*reward)->reward(player);
         COUT(4) << "Rewardable successfully added to player." << player << " ." << std::endl;
+        orxout(verbose, context::quests) << "Rewardable successfully added to player." << player << " ." << endl;
         return temp;

code/trunk/src/modules/questsystem/effects/ChangeQuestStatus.cc

r8079	r8858
83	83	if(id == "")
84	84	{
85		~~COUT(2) << "Invalid id. QuestItem id {" << id << "} could not be set." << std::~~endl;
	85	orxout(internal_warning, context::quests) << "Invalid id. QuestItem id {" << id << "} could not be set." << endl;
86	86	return false;
87	87	}

code/trunk/src/modules/questsystem/effects/CompleteQuest.cc

-                      r7552
+                      r8858
         SUPER(CompleteQuest, XMLPort, xmlelement, mode);
         COUT(4) << "New CompleteQuest, with target Quest {" << this->getQuestId() << "}, created." << std::endl;
+        orxout(verbose, context::quests) << "New CompleteQuest, with target Quest {" << this->getQuestId() << "}, created." << endl;
+    }
 …
         assert(player);
         COUT(5) << "CompleteQuest on player: " << player << " ." << std::endl;
+        orxout(verbose_more, context::quests) << "CompleteQuest on player: " << player << " ." << endl;
         Quest* quest;
 …
         catch(const Exception& e)
+        {
             COUT(2) << e.getFullDescription() << std::endl;
+            orxout(internal_warning, context::quests) << e.getFullDescription() << endl;
             return false;
+        }
         COUT(4) << "Quest {" << quest->getId() << "} successfully completed by player: " << player << " ." << std::endl;
+        orxout(verbose, context::quests) << "Quest {" << quest->getId() << "} successfully completed by player: " << player << " ." << endl;
         return true;
+    }

code/trunk/src/modules/questsystem/effects/FailQuest.cc

-                      r7552
+                      r8858
         SUPER(FailQuest, XMLPort, xmlelement, mode);
         COUT(4) << "New FailQuest, with target Quest {" << this->getQuestId() << "}, created." << std::endl;
+        orxout(verbose, context::quests) << "New FailQuest, with target Quest {" << this->getQuestId() << "}, created." << endl;
+    }
 …
         assert(player);
         COUT(4) << "FailQuest on player: " << player << " ." << std::endl;
+        orxout(verbose, context::quests) << "FailQuest on player: " << player << " ." << endl;
         Quest* quest;
 …
         catch(const Exception& e)
+        {
             COUT(2) << e.getFullDescription() << std::endl;
+            orxout(internal_warning, context::quests) << e.getFullDescription() << endl;
             return false;
+        }
         COUT(4) << "Quest {" << quest->getId() << "} failed by player: " << player << " ." << std::endl;
+        orxout(verbose, context::quests) << "Quest {" << quest->getId() << "} failed by player: " << player << " ." << endl;
         return true;
+    }

code/trunk/src/modules/tetris/Tetris.cc

r8706	r8858
165	165	else // If no centerpoint was specified, an error is thrown and the level is exited.
166	166	{
167		~~COUT(1) << "Error: No Centerpoint specified." << std::~~endl;
	167	orxout(internal_error) << "Tetris: No Centerpoint specified." << endl;
168	168	GSLevel::startMainMenu();
169	169	return;

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

r8855	r8858
48	48	{
49	49	RegisterObject(RocketController);
50		~~COUT(5)<< "RocketController constructed\n"~~;
	50	// orxout() << "RocketController constructed" << endl;
51	51
52	52	// Create a rocket for the controller.
…	…
73	73	RocketController::~RocketController()
74	74	{
75		~~COUT(5)<< "RocketController destroyed\n"~~;
	75	// orxout() << "RocketController destroyed" << endl;
76	76	}
77	77

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

-                      r8855
+                      r8858
             */
             inline void setDamage(float damage)
                 { if(damage >= 0.0f)  { this->damage_ = damage; return; } COUT(1) << "The input projectile damage must be non-negative. Ignoring..." << endl; }
+                { if(damage >= 0.0f)  { this->damage_ = damage; return; } orxout(internal_warning) << "The input projectile damage must be non-negative. Ignoring..." << endl; }
             /**
             @brief Get the normal damage done by this projectile.
 …
             */
             inline void setHealthDamage(float healthdamage)
                 { if(healthdamage >= 0.0f)  { this->healthdamage_ = healthdamage; return; } COUT(1) << "The input projectile health-damage must be non-negative. Ignoring..." << endl; }
+                { if(healthdamage >= 0.0f)  { this->healthdamage_ = healthdamage; return; } orxout(internal_warning) << "The input projectile health-damage must be non-negative. Ignoring..." << endl; }
             /**
             @brief Get the health-damage done by this projectile.
 …
             */
             inline void setShieldDamage(float shielddamage)
                 { if(shielddamage >= 0.0f)  { this->shielddamage_ = shielddamage; return; } COUT(1) << "The input projectile shield-damage must be non-negative. Ignoring..." << endl; }
+                { if(shielddamage >= 0.0f)  { this->shielddamage_ = shielddamage; return; } orxout(internal_warning) << "The input projectile shield-damage must be non-negative. Ignoring..." << endl; }
             /**
             @brief Get the shield-damage done by this projectile.

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

r8855	r8858
39	39	#include "core/CoreIncludes.h"
40	40	#include "core/XMLPort.h"
41		~~#include "util/Debug.h"~~
42	41
43	42	#include "controllers/Controller.h"

code/trunk/src/orxonox/CMakeLists.txt

-                      r8729
+                      r8858
   PlayerManager.cc
   Radar.cc
-  ChatHistory.cc
-  ChatInputHandler.cc
 #  Test.cc
 …
+)
+ADD_SUBDIRECTORY(chat)
 ADD_SUBDIRECTORY(collisionshapes)
 ADD_SUBDIRECTORY(controllers)
 …
   FIND_HEADER_FILES
   TOLUA_FILES
     ChatInputHandler.h
+    chat/ChatInputHandler.h
     LevelInfo.h
     LevelManager.h

code/trunk/src/orxonox/Level.cc

r7648	r8858
88	88	void Level::networkcallback_applyXMLFile()
89	89	{
90		~~COUT(0) << "Loading level \"" << this->xmlfilename_ << "\"..." << std::~~endl;
	90	orxout(user_status) << "Loading level \"" << this->xmlfilename_ << "\"..." << endl;
91	91
92	92	ClassTreeMask mask;
…	…
115	115	if (!identifier \|\| !identifier->isA(Class(Gametype)))
116	116	{
117		~~COUT(0) << "Error: \"" << gametype << "\" is not a valid gametype." << std::~~endl;
	117	orxout(internal_error) << "\"" << gametype << "\" is not a valid gametype." << endl;
118	118	identifier = Class(Gametype);
119	119	this->gametype_ = "Gametype";
…	…
157	157	// this->lodInformation_.insert(std::make_pair(meshName,lodInformation));
158	158	if( this->lodInformation_.find(meshName) != this->lodInformation_.end())
159		~~CCOUT(4~~) << "replacing lod information for " << meshName << endl;
	159	orxout(verbose, context::lod) << "replacing lod information for " << meshName << endl;
160	160	this->lodInformation_[meshName] = lodInformation;
161	161	}
…	…
171	171	void Level::playerEntered(PlayerInfo* player)
172	172	{
173		~~COUT(3) << "player entered level (id: " << player->getClientID() << ", name: " << player->getName() << ')' << std::~~endl;
	173	orxout(internal_info) << "player entered level (id: " << player->getClientID() << ", name: " << player->getName() << ')' << endl;
174	174	player->setGametype(this->getGametype());
175	175	}
…	…
177	177	void Level::playerLeft(PlayerInfo* player)
178	178	{
179		~~COUT(3) << "player left level (id: " << player->getClientID() << ", name: " << player->getName() << ')' << std::~~endl;
	179	orxout(internal_info) << "player left level (id: " << player->getClientID() << ", name: " << player->getName() << ')' << endl;
180	180	player->setGametype(0);
181	181	}

code/trunk/src/orxonox/LevelInfo.cc

r7652	r8858
125	125	if(!this->validateTag(tag))
126	126	{
127		~~COUT(2) << "Bad LevelInfo tag '" << tag << "' in " << this->getXMLFilename() << ". Ignoring..." << std::~~endl;
	127	orxout(internal_warning) << "Bad LevelInfo tag '" << tag << "' in " << this->getXMLFilename() << ". Ignoring..." << endl;
128	128	return false;
129	129	}

code/trunk/src/orxonox/LevelManager.cc

-                      r8706
+                      r8858
         // Iterate over all the found *.oxw files
         COUT(3) << "Loading LevelInfos..." << std::endl;
+        orxout(internal_info) << "Loading LevelInfos..." << endl;
         std::set<std::string> names;
         for (Ogre::StringVector::const_iterator it = levels->begin(); it != levels->end(); ++it)
 …
                 // Warn about levels with the same name.
                 if(!names.insert(info->getName()).second)
                     COUT(2) << "Warning: Multiple levels (" << info->getXMLFilename() << ") with name '" << info->getName() << "' found!" << std::endl;
+                    orxout(internal_warning) << "Multiple levels (" << info->getXMLFilename() << ") with name '" << info->getName() << "' found!" << endl;
                 // Warn about multiple items so that it gets fixed quickly
                 if(availableLevels_.find(info) != availableLevels_.end())
+                {
                     COUT(2) << "Warning: Multiple levels (" << info->getXMLFilename() << ") with same name '" << info->getName() << "' and filename found! Exluding..." << std::endl;
+                    orxout(internal_warning) << "Multiple levels (" << info->getXMLFilename() << ") with same name '" << info->getName() << "' and filename found! Exluding..." << endl;
                     // Delete LevelInfoItem to avoid a dangling pointer
                     delete info;

code/trunk/src/orxonox/Main.cc

r8729	r8858
61	61	int main(const std::string& strCmdLine)
62	62	{
	63	orxout(internal_status) << "entering orxonox::main()" << endl;
	64	orxout(internal_info) << "command line: " << strCmdLine << endl;
	65
	66	orxout(internal_info) << "creating Game object:" << endl;
63	67	Game* game = new Game(strCmdLine);
	68	orxout(user_status) << "Finished initialization" << endl;
64	69
65	70	if (CommandLineParser::getValue("generateDoc").getString().empty())
66	71	{
	72	orxout(internal_info) << "preparing game states" << endl;
	73
67	74	/* TODO make this clear */
68	75	game->setStateHierarchy(
…	…
98	105	}
99	106
	107	orxout(internal_info) << "starting game" << endl;
100	108	game->run();
101	109	}

code/trunk/src/orxonox/MoodManager.cc

r8706	r8858
54	54	{
55	55	// TODO: Non-fatal error handling (non-critical resource missing)
56		~~COUT(2) << "Mood Warning: Folder for default mood (" << MoodManager::defaultMood_ << ") does not exist!" << std::~~endl;
	56	orxout(internal_warning) << "Mood Warning: Folder for default mood (" << MoodManager::defaultMood_ << ") does not exist!" << endl;
57	57	}
58	58
…	…
82	82	if (!Resource::exists(path))
83	83	{
84		~~COUT(3) << "Mood " << mood_ << " does not exist. Will not change." << std::~~endl;
	84	orxout(internal_warning) << "Mood " << mood_ << " does not exist. Will not change." << endl;
85	85	this->setMood(oldMood_);
86	86	}
87	87	else
88	88	{
89		~~COUT(3) << "Mood changed to " << mood_ << std::~~endl;
	89	orxout(internal_info) << "Mood changed to " << mood_ << endl;
90	90	MoodListener::changedMood(mood_);
91	91	}

code/trunk/src/orxonox/OrxonoxPrereqs.h

-                      r8351
+                      r8858
     class Radar;
     class Scene;
+    // chat
+    class ChatHistory;
+    class ChatInputHandler;
+    class ChatListener;
+    class ChatManager;
     // collisionshapes

code/trunk/src/orxonox/PlayerManager.cc

-                      r8327
+                      r8858
+        {
             if (clientID != 0)
                 COUT(3) << "client connected" << std::endl;
+                orxout(internal_info) << "client connected" << endl;
             // create new HumanPlayer instance
 …
+        {
             if (clientID != 0)
                 COUT(3) << "client disconnected" << std::endl;
+                orxout(internal_info) << "client disconnected" << endl;
             // remove from clients-map

code/trunk/src/orxonox/Radar.cc

r7284	r8858
195	195	void Radar::listObjects() const
196	196	{
197		~~COUT(3) << "List of RadarObjects:\n"~~;
	197	orxout(debug_output) << "List of RadarObjects:" << endl;
198	198	// iterate through all Radar Objects
199	199	unsigned int i = 0;
200	200	for (ObjectList<RadarViewable>::iterator it = ObjectList<RadarViewable>::begin(); it; ++it, ++i)
201	201	{
202		~~COUT(3) << i++ << ": " << (*it)->getRVWorldPosition() << std::~~endl;
	202	orxout(debug_output) << i++ << ": " << (*it)->getRVWorldPosition() << endl;
203	203	}
204	204	}

code/trunk/src/orxonox/Scene.cc

-                      r7163
+                      r8858
         if (range.length() < 10.0f)
+        {
             CCOUT(2) << "Warning: Setting the negative world range to a very small value: "
                      << multi_cast<std::string>(range) << std::endl;
+        }
         if (this->hasPhysics())
+        {
             CCOUT(2) << "Warning: Attempting to set the physical world range at run time. "
                      << "This causes a complete physical reload which might take some time." << std::endl;
+            orxout(internal_warning) << "Setting the negative world range to a very small value: "
+                                     << multi_cast<std::string>(range) << endl;
+        }
+        if (this->hasPhysics())
+        {
+            orxout(internal_warning) << "Attempting to set the physical world range at run time. "
+                                     << "This causes a complete physical reload which might take some time." << endl;
             this->setPhysicalWorld(false);
             this->negativeWorldRange_ = range;
 …
         if (range.length() < 10.0f)
+        {
             CCOUT(2) << "Warning: Setting the positive world range to a very small value: "
                      << multi_cast<std::string>(range) << std::endl;
+        }
         if (this->hasPhysics())
+        {
             CCOUT(2) << "Warning: Attempting to set the physical world range at run time. "
                      << "This causes a complete physical reload which might take some time." << std::endl;
+            orxout(internal_warning) << "Setting the positive world range to a very small value: "
+                                     << multi_cast<std::string>(range) << endl;
+        }
+        if (this->hasPhysics())
+        {
+            orxout(internal_warning) << "Attempting to set the physical world range at run time. "
+                                     << "This causes a complete physical reload which might take some time." << endl;
             this->setPhysicalWorld(false);
             this->positiveWorldRange_ = range;

code/trunk/src/orxonox/Test.cc

-                      r7284
+                      r8858
     //     mt2.importData( temp );
     //     assert( temp-mem == mt1.getNetworkSize() );
     //     COUT(0) << mt2 << endl;
+    //     orxout() << mt2 << endl;
     //     if(!Core::isMaster())
     //       call2(0, "bal", "a", "n", "ce");
 …
     void Test::printBlaBla(std::string s1, std::string s2, std::string s3, std::string s4, std::string s5)
+    {
         COUT(0) << s1 << s2 << s3 << s4 << s5 << endl;
+        orxout() << s1 << s2 << s3 << s4 << s5 << endl;
+    }
     void Test::checkU1(){ COUT(1) << "U1 changed: " << u1 << std::endl; }
     void Test::checkU2(){ COUT(1) << "U2 changed: " << u2 << std::endl; }
     void Test::checkU3(){ COUT(1) << "U3 changed: " << u3 << std::endl; }
     void Test::checkU4(){ COUT(1) << "U4 changed: " << u4 << std::endl; }
+    void Test::checkU1(){ orxout() << "U1 changed: " << u1 << endl; }
+    void Test::checkU2(){ orxout() << "U2 changed: " << u2 << endl; }
+    void Test::checkU3(){ orxout() << "U3 changed: " << u3 << endl; }
+    void Test::checkU4(){ orxout() << "U4 changed: " << u4 << endl; }
     void Test::checkS1(){ COUT(1) << "S1 changed: " << s1 << std::endl; }
     void Test::checkS2(){ COUT(1) << "S2 changed: " << s2 << std::endl; }
     void Test::checkS3(){ COUT(1) << "S3 changed: " << s3 << std::endl; }
     void Test::checkS4(){ COUT(1) << "S4 changed: " << s4 << std::endl; }
+    void Test::checkS1(){ orxout() << "S1 changed: " << s1 << endl; }
+    void Test::checkS2(){ orxout() << "S2 changed: " << s2 << endl; }
+    void Test::checkS3(){ orxout() << "S3 changed: " << s3 << endl; }
+    void Test::checkS4(){ orxout() << "S4 changed: " << s4 << endl; }
     void Test::printPointer(){ CCOUT(1) << "pointer: " << this->pointer_ << endl; }
+    void Test::printPointer(){ orxout() << "pointer: " << this->pointer_ << endl; }
+}

code/trunk/src/orxonox/Test.h

r7163	r8858
108	108
109	109	void blub2()
110		{ for( std::set<uint32_t>::iterator it=mySet_.begin(); it!=mySet_.end(); ++it ) ~~COUT(0~~) << *it << endl; }
	110	{ for( std::set<uint32_t>::iterator it=mySet_.begin(); it!=mySet_.end(); ++it ) orxout() << *it << endl; }
111	111	};
112	112	}

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

r8706	r8858
203	203	if(scale_.crossProduct(scale).squaredLength() != 0.0f)
204	204	{
205		~~CCOUT(2) << "Warning:~~ Non-uniform scaling is not yet supported." << endl;
	205	orxout(internal_warning) << "Non-uniform scaling is not yet supported." << endl;
206	206	return;
207	207	}

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

r8706	r8858
98	98	if (this->attachedShapes_.find(shape) != this->attachedShapes_.end())
99	99	{
100		~~CCOUT(2) << "Warning: Attaching a CollisionShape twice is not yet supported." << std::~~endl;
	100	orxout(internal_warning) << "Attaching a CollisionShape twice is not yet supported." << endl;
101	101	return;
102	102	}
…	…
139	139	}
140	140	else
141		~~CCOUT(2) << "Warning: Cannot detach non child collision shape" << std::~~endl;
	141	orxout(internal_warning) << "Cannot detach non child collision shape" << endl;
142	142	}
143	143
…	…
168	168	if (it == this->attachedShapes_.end())
169	169	{
170		~~CCOUT(2) << "Warning: Cannot update child shape: Instance not a child." << std::~~endl;
	170	orxout(internal_warning) << "Cannot update child shape: Instance not a child." << endl;
171	171	return;
172	172	}

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

r8706	r8858
98	98	if (it->myMaster_ == this)
99	99	{
100		~~COUT(1) << "error: " << this << " is still master in " << (*it) << std::~~endl;
	100	orxout(internal_error) << this << " is still master in " << (*it) << endl;
101	101	it->myMaster_ = 0;
102	102	}
…	…
107	107	if (it2 != it->slaves_.end())
108	108	{
109		~~COUT(1) << "error: " << this << " is still slave in " << (*it) << std::~~endl;
	109	orxout(internal_error) << this << " is still slave in " << (*it) << endl;
110	110	it->slaves_.erase(it2);
111	111	}
…	…
737	737	float speedDiv = this->getControllableEntity()->getVelocity().squaredLength() - this->target_->getVelocity().squaredLength();
738	738
739		~~COUT(0) << "~follow distance: " << distance << "SpeedCounter: " << this->speedCounter_ << "~speedDiv: " << speedDiv << std::~~endl;
	739	orxout() << "~follow distance: " << distance << "SpeedCounter: " << this->speedCounter_ << "~speedDiv: " << speedDiv << endl;
740	740	if (distance < 800)
741	741	{

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

r8706	r8858
93	93	Camera* camera = HumanController::localController_s->controllableEntity_->getCamera();
94	94	if (!camera)
95		~~COUT(3) << "HumanController, Warning: Using a ControllableEntity without Camera" << std::~~endl;
	95	orxout(internal_warning) << "HumanController, Warning: Using a ControllableEntity without Camera" << endl;
96	96	}
97	97	}
…	…
197	197
198	198	this->controllableEntity_->boost(this->boosting_);
199		~~COUT(4~~) << "Start boosting" << endl;
	199	// orxout() << "Start boosting" << endl;
200	200	}
201	201	}
…	…
211	211
212	212	this->controllableEntity_->boost(this->boosting_);
213		~~COUT(4~~) << "Stop boosting" << endl;
	213	// orxout() << "Stop boosting" << endl;
214	214	}
215	215
…	…
257	257	const Quaternion& orientation = HumanController::localController_s->controllableEntity_->getOrientation();
258	258
259		~~COUT(0) << "position=\"" << position.x << ", " << position.y << ", " << position.z << "\" ";~~
260		~~COUT(0) << "orientation=\"" << orientation.w << ", " << orientation.x << ", " << orientation.y << ", " << orientation.z << "\"" << std::~~endl;
	259	orxout(message) << "position=\"" << position.x << ", " << position.y << ", " << position.z << "\" "
	260	<< "orientation=\"" << orientation.w << ", " << orientation.x << ", " << orientation.y << ", " << orientation.z << "\"" << endl;
261	261	}
262	262	}

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

r8436	r8858
388	388	for (itr = result.begin(); itr != result.end(); ++itr)
389	389	{
390		// ~~CCOUT(0~~) << "testing object as target" << endl;
	390	// orxout() << "testing object as target" << endl;
391	391	if (itr->movable->isInScene() && itr->movable->getMovableType() == "Entity" && itr->distance > 200)
392	392	{

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

-                      r7163
+                      r8858
 #include "GSClient.h"
-#include "util/Debug.h"
 #include "util/Exception.h"
 #include "core/CommandLineParser.h"
 …
     void GSClient::activate()
+    {
+        orxout(user_status) << "Starting client" << endl;
         GameMode::setIsClient(true);

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

-                      r8729
+                      r8858
     void GSLevel::activate()
+    {
+        orxout(user_status) << "Loading level" << endl;
         if (GameMode::showsGraphics())
+        {
 …
         // call the loader
-        COUT(0) << "Loading level..." << std::endl;
         startFile_ = new XMLFile(LevelManager::getInstance().getDefaultLevel());
         bool loaded = Loader::open(startFile_);
 …
         delete startFile_;
         COUT(3) << "Unloaded level. Remaining objects:" << std::endl;
+        orxout(internal_info) << "Remaining objects:" << endl;
         unsigned int i = 0;
         for (ObjectList<BaseObject>::iterator it = ObjectList<BaseObject>::begin(); it != ObjectList<BaseObject>::end(); ++it)
 …
             if (find == this->staticObjects_.end())
+            {
                 COUT(3) << ++i << ": " << it->getIdentifier()->getName() << " (" << *it << "), references: " << it->getReferenceCount() << std::endl;
+                orxout(internal_info) << ++i << ": " << it->getIdentifier()->getName() << " (" << *it << "), references: " << it->getReferenceCount() << endl;
+            }
+        }
         COUT(3) << i << " objects remaining.";
+        orxout(internal_info) << i << " objects remaining.";
         if (i == 0)
             COUT(3) << " Well done!" << std::endl;
+            orxout(internal_info) << " Well done!" << endl;
         else
             COUT(3) << " Try harder!" << std::endl;
+            orxout(internal_info) << " Try harder!" << endl;
+    }

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

r8079	r8858
95	95	void GSMainMenu::activate()
96	96	{
	97	orxout(user_status) << "Loading main menu" << endl;
	98
97	99	// show main menu
98	100	GraphicsManager::getInstance().setCamera(this->camera_);

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

-                      r7801
+                      r8858
 #include "GSMasterServer.h"
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "core/Game.h"
 #include "core/GameMode.h"
 …
   void GSMasterServer::activate()
+  {
+    orxout(user_status) << "Starting masterserver" << endl;
     /* TODO make this work for masterserver as well */
     //GameMode::setIsServer(true);
     this->mserver = new MasterServer();
-    COUT(0) << "Loading masterserver mode" << std::endl;
     this->mserver->run();
+  }

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

r8706	r8858
77	77	{
78	78	if (dynamic_cast<Synchronisable>(it))
79		~~COUT(0) << "object: " << it->getIdentifier()->getName() << " id: " << dynamic_cast<Synchronisable>(it)->getObjectID() << std::~~endl;
	79	orxout(debug_output) << "object: " << it->getIdentifier()->getName() << " id: " << dynamic_cast<Synchronisable>(it)->getObjectID() << endl;
80	80	else
81		~~COUT(0) << "object: " << it->getIdentifier()->getName() << std::~~endl;
	81	orxout(debug_output) << "object: " << it->getIdentifier()->getName() << endl;
82	82	nr++;
83	83	}
84		~~COUT(0) << "currently got " << nr << " objects" << std::~~endl;
	84	orxout(debug_output) << "currently got " << nr << " objects" << endl;
85	85	}
86	86

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

-                      r7801
+                      r8858
 #include "GSServer.h"
 #include "util/Debug.h"
+#include "util/Output.h"
 #include "core/CommandLineParser.h"
 #include "core/Game.h"
 …
     void GSServer::activate()
+    {
+        orxout(user_status) << "Starting server" << endl;
         GameMode::setIsServer(true);
         this->server_ = new Server(CommandLineParser::getValue("port"));
         COUT(0) << "Loading scene in server mode" << std::endl;
+        orxout(user_status) << "Loading scene in server mode" << endl;
         server_->open();

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

-                      r7655
+                      r8858
 #include "core/CoreIncludes.h"
 #include "network/Host.h"
+#include "chat/ChatManager.h"
 #include "worldentities/pawns/Pawn.h"
 …
         std::string message("The match has started! Reach the first chekpoint within 15 seconds! But be aware, there may be pirates around...");
+        COUT(0) << message << std::endl;
+        Host::Broadcast(message);
+        ChatManager::message(message);
+    }
 …
         std::string message("The match has ended.");
+        COUT(0) << message << std::endl;
+        Host::Broadcast(message);
+        ChatManager::message(message);
+    }
+}

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

r6417	r8858
30	30
31	31	#include "core/CoreIncludes.h"
32		#include "~~network/Host~~.h"
	32	#include "chat/ChatManager.h"
33	33	#include "infos/PlayerInfo.h"
34	34	#include "worldentities/pawns/Pawn.h"
…	…
48	48
49	49	std::string message("The match has started!");
50		COUT(0) << message << std::endl;
51		Host::Broadcast(message);
	50	ChatManager::message(message);
52	51	}
53	52
…	…
57	56
58	57	std::string message("The match has ended.");
59		COUT(0) << message << std::endl;
60		Host::Broadcast(message);
	58	ChatManager::message(message);
61	59	}
62	60
…	…
66	64
67	65	const std::string& message = player->getName() + " entered the game";
68		COUT(0) << message << std::endl;
69		Host::Broadcast(message);
	66	ChatManager::message(message);
70	67	}
71	68
…	…
77	74	{
78	75	const std::string& message = player->getName() + " left the game";
79		COUT(0) << message << std::endl;
80		Host::Broadcast(message);
	76	ChatManager::message(message);
81	77	}
82	78
…	…
91	87	{
92	88	const std::string& message = player->getOldName() + " changed name to " + player->getName();
93		COUT(0) << message << std::endl;
94		Host::Broadcast(message);
	89	ChatManager::message(message);
95	90	}
96	91
…	…
113	108	message = victim->getPlayer()->getName() + " died";
114	109
115		COUT(0) << message << std::endl;
116		Host::Broadcast(message);
	110	ChatManager::message(message);
117	111	}
118	112
…	…
127	121	{
128	122	const std::string& message = player->getName() + " scores!";
129		COUT(0) << message << std::endl;
130		Host::Broadcast(message);
	123	ChatManager::message(message);
131	124	}
132	125	}

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

-                      r8729
+                      r8858
 #include "core/CoreIncludes.h"
 #include "core/command/Executor.h"
 #include "network/Host.h"
+#include "chat/ChatManager.h"
 #include "infos/PlayerInfo.h"
 #include "worldentities/pawns/Pawn.h"
 …
         numberOf[chaser]++;
         Gametype::playerEntered(player);
+        const std::string& message6 = player->getName() + " entered the game";
+        COUT(0) << message6 << std::endl;
+        Host::Broadcast(message6);
+        const std::string& message = player->getName() + " entered the game";
+        ChatManager::message(message);
+    }
 …
+            }
             const std::string& message = player->getName() + " left the game";
+            COUT(0) << message << std::endl;
+            Host::Broadcast(message);
+            ChatManager::message(message);
             //remove player from map
             playerParty_.erase (player);
 …
+        {
             const std::string& message = player->getOldName() + " changed name to " + player->getName();
+            COUT(0) << message << std::endl;
+            Host::Broadcast(message);
+            ChatManager::message(message);
+        }
 …
+        {
             std::string message("Dynamicmatch started!");
+            COUT(0) << message << std::endl;
+            Host::Broadcast(message);
+            ChatManager::message(message);
+        }
         else if(tutorial) // Announce selectionphase
 …
+    {
         std::string message("Earn points:\n\n\n\tIf you're red: Chase the blue player!\n\n\tIf you're blue shoot at a red player or hide.\n\n\tIf you're green: You've got the licence to kill red players!");
+        COUT(0) << message << std::endl;
+        Host::Broadcast(message);
+        ChatManager::message(message);
         callInstructions_.setTimer(10, false, createExecutor(createFunctor(&Dynamicmatch::furtherInstructions, this)));
+    }
 …
+    {
         std::string message("After 3 Minutes the game is over.");
+        COUT(0) << message << std::endl;
+        Host::Broadcast(message);
+        ChatManager::message(message);
     }*/
     void Dynamicmatch::end()
 …
         std::string message("Time out. Press F2 to see the points you scored.");
+        COUT(0) << message << std::endl;
+        Host::Broadcast(message);
+        ChatManager::message(message);
+    }
     SpawnPoint* Dynamicmatch::getBestSpawnPoint(PlayerInfo* player) const

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

r8706	r8858
297	297	}
298	298	else
299		~~COUT(2) << "Warning: Killed Pawn was not in the playerlist" << std::~~endl;
	299	orxout(internal_warning) << "Killed Pawn was not in the playerlist" << endl;
300	300	}
301	301	}
…	…
344	344	}
345	345
346		~~COUT(2) << "Warning: Fallback SpawnPoint was used,~~ because there were no active SpawnPoints." << endl;
	346	orxout(internal_warning) << "Fallback SpawnPoint was used because there were no active SpawnPoints." << endl;
347	347	return fallbackSpawnPoint;
348	348	}
…	…
444	444	else
445	445	{
446		~~COUT(1) << "Error: No SpawnPoints in current Gametype" << std::~~endl;
	446	orxout(user_error) << "No SpawnPoints in current Gametype" << endl;
447	447	abort();
448	448	}
…	…
461	461	else
462	462	{
463		~~COUT(1) << "Error: No SpawnPoints in current Gametype" << std::~~endl;
	463	orxout(user_error) << "No SpawnPoints in current Gametype" << endl;
464	464	abort();
465	465	}

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

-                      r8327
+                      r8858
 #include "core/CoreIncludes.h"
 #include "network/Host.h"
+#include "chat/ChatManager.h"
 #include "infos/PlayerInfo.h"
 #include "worldentities/pawns/Pawn.h"
 …
                 const std::string& message = ""; // resets Camper-Warning-message
                 this->gtinfo_->sendFadingMessage(message,it->first->getClientID());
+            }
+            }
+        }
         return true;
 …
             this->playersAlive--;
             const std::string& message = victim->getPlayer()->getName() + " has lost all lives";
+            COUT(0) << message << std::endl;
+            Host::Broadcast(message);
+            ChatManager::message(message);
+        }
 …
+    {
         Gametype::end();
         for (std::map<PlayerInfo*, int>::iterator it = this->playerLives_.begin(); it != this->playerLives_.end(); ++it)
+        {
 …
             return 0;
+    }
     int LastManStanding::getNumPlayersAlive() const
+    {
 …
         this->timeToAct_[player]=timeRemaining+3.0f+respawnDelay;//reset timer
         this->playerDelayTime_[player]=respawnDelay;
         std::map<PlayerInfo*, Player>::iterator it = this->players_.find(player);
         if (it != this->players_.end())
 …
             const std::string& message = ""; // resets Camper-Warning-message
             this->gtinfo_->sendFadingMessage(message,it->first->getClientID());
+        }
+        }
+    }
 …
+            }
             for (std::map<PlayerInfo*, float>::iterator it = this->timeToAct_.begin(); it != this->timeToAct_.end(); ++it)
+            {
+            {
                 if (playerGetLives(it->first)<=0)//Players without lives shouldn't be affected by time.
                     continue;
+                    continue;
                 it->second-=dt;//Decreases punishment time.
                 if (!inGame_[it->first])//Manages respawn delay - player is forced to respawn after the delaytime is used up.
+                if (!inGame_[it->first])//Manages respawn delay - player is forced to respawn after the delaytime is used up.
+                {
                     playerDelayTime_[it->first]-=dt;

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

-                      r8706
+                      r8858
 #include "core/CoreIncludes.h"
+#include "network/NetworkPrereqs.h"
+#include "network/Host.h"
+#include "chat/ChatManager.h"
 #include "infos/PlayerInfo.h"
 #include "worldentities/pawns/Pawn.h"
 …
                 this->teamsAlive--;
             const std::string& message = victim->getPlayer()->getName() + " has lost all lives";
+            COUT(0) << message << std::endl;
+            Host::Broadcast(message);
+            ChatManager::message(message);
+        }
         return allow;

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

r8327	r8858
141	141	return;
142	142
143		~~COUT(0) << "Points standing:" << std::endl << "Team 1: "<< pointsTeam1_ << std::endl << "Team 2: " << pointsTeam2_ << std::~~endl;
144		if(pointsTeam1_ >=1700 && pointsTeam1_ < 2000) ~~COUT(0) << "Team 1 is near victory!" << std::~~endl;
145		if(pointsTeam2_ >=1700 && pointsTeam2_ < 2000) ~~COUT(0) << "Team 2 is near victory!" << std::~~endl;
	143	orxout(message) << "Points standing:" << '\n' << "Team 1: "<< pointsTeam1_ << '\n' << "Team 2: " << pointsTeam2_ << endl;
	144	if(pointsTeam1_ >=1700 && pointsTeam1_ < 2000) orxout(message) << "Team 1 is near victory!" << endl;
	145	if(pointsTeam2_ >=1700 && pointsTeam2_ < 2000) orxout(message) << "Team 2 is near victory!" << endl;
146	146	}
147	147
…	…
179	179	if (this->pointsTeam1_ > this->pointsTeam2_)
180	180	{
181		~~COUT(0) << "Team 1 has won the match" << std::~~endl;
	181	orxout(message) << "Team 1 has won the match" << endl;
182	182	winningteam = 0;
183	183	}
184	184	else
185	185	{
186		~~COUT(0) << "Team 2 has won the match" << std::~~endl;
	186	orxout(message) << "Team 2 has won the match" << endl;
187	187	winningteam = 1;
188	188	}

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

-                      r8327
+                      r8858
 #include "core/CoreIncludes.h"
 #include "core/ConfigValueIncludes.h"
 #include "network/Host.h"
+#include "chat/ChatManager.h"
 #include "worldentities/pawns/Destroyer.h"
 #include "infos/PlayerInfo.h"
 …
         this->end(); //end gametype
         std::string message("Ship destroyed! Team 0 has won!");
+        COUT(0) << message << std::endl;
+        Host::Broadcast(message);
+        ChatManager::message(message);
         this->gameEnded_ = true;
 …
                 this->end();
                 std::string message("Time is up! Team 1 has won!");
+                COUT(0) << message << std::endl;
+                Host::Broadcast(message);
+                ChatManager::message(message);
                 for (std::map<PlayerInfo*, int>::iterator it = this->teamnumbers_.begin(); it != this->teamnumbers_.end(); ++it)
 …
                 const std::string& message = multi_cast<std::string>(timesequence_) + " seconds left!";
 /*
+                COUT(0) << message << std::endl;
+                Host::Broadcast(message);
+                ChatManager::message(message);
 */
                 this->gtinfo_->sendAnnounceMessage(message);

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

-                      r7163
+                      r8858
  *   Author:
  *      Benjamin de Capitani
+ *
+ *   Co-authors:
+ *      ...
+ *
  */

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

r7163	r8858
21	21	*
22	22	* Author:
23		* ~~Fabian 'x3n' Landau~~
	23	* Benjamin de Capitani
24	24	* Co-authors:
25	25	* ...

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

r8079	r8858
142	142	if( this->numLodLevels_>10 )
143	143	{
144		~~CCOUT(2~~) << "More than 10 LoD levels requested. Creating only 10." << endl;
	144	orxout(internal_warning, context::lod) << "More than 10 LoD levels requested. Creating only 10." << endl;
145	145	this->numLodLevels_ = 10;
146	146	}
…	…
158	158	creatorPtr = creatorPtr->getCreator();
159	159	}
160		~~COUT(0~~) << "name: " << this->meshSrc_ << "scaleFactor: " << scaleFactor << ", volume: " << volume << endl;
	160	orxout() << "name: " << this->meshSrc_ << "scaleFactor: " << scaleFactor << ", volume: " << volume << endl;
161	161	*/
162		~~COUT(4) << "Setting lodLevel for " << this->meshSrc_<< " with lodLevel_: " << this->lodLevel_ <<" and volume: "<< volume << ":" << std::~~endl;
	162	orxout(verbose, context::lod) << "Setting lodLevel for " << this->meshSrc_<< " with lodLevel_: " << this->lodLevel_ <<" and volume: "<< volume << ":" << endl;
163	163
164	164	#if OGRE_VERSION >= 0x010700
…	…
173	173	float factor = pow(volume, 2.0f / 3.0f) * 15.0f / lodLevel_;
174	174
175		~~COUT(4~~) << "LodLevel set with factor: " << factor << endl;
	175	orxout(verbose, context::lod) << "LodLevel set with factor: " << factor << endl;
176	176
177	177	distList.push_back(70.0f*factor);
…	…
200	200	what = "<0";
201	201
202		~~COUT(4)<<"LodLevel not set because lodLevel("<<lodLevel_<<") was "<<what<<~~"." << endl;
	202	orxout(verbose, context::lod) << "LodLevel not set because lodLevel(" << lodLevel_ << ") was " << what << "." << endl;
203	203	}
204	204	}
205	205	else
206		~~COUT(4~~) << "LodLevel for " << this->meshSrc_ << " not set because is disabled." << endl;
	206	orxout(verbose, context::lod) << "LodLevel for " << this->meshSrc_ << " not set because is disabled." << endl;
207	207	}
208	208	}

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

r7174	r8858
116	116	catch (const std::exception& ex)
117	117	{
118		~~COUT(1) << "Error: Couln't load particle effect \"" << this->source_ << "\" because:" << std::~~endl
119		~~<< ex.what() << std::~~endl;
	118	orxout(internal_error) << "Couldn't load particle effect \"" << this->source_ << "\" because:" << endl
	119	<< ex.what() << endl;
120	120	}
121	121	}

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

r8706	r8858
196	196	this->startCountdown_ = countdown;
197	197	// Set the counter to the ceiling of the current countdown.
198		this->counter_ = st~~d::ceil(countdown~~);
	198	this->counter_ = static_cast<unsigned int>(std::ceil(countdown));
199	199	this->changedCountdownCounter();
200	200	}

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

r8351	r8858
75	75	if(it != this->pickups_.end() && temp == *it) // Infinite loop avoidance, in case the pickup wasn't removed from the carrier somewhere in the carrierDestroy() procedure.
76	76	{
77		~~COUT(2) << "Oops. In a PickupCarrier, while cleaning up, a Pickupable (&" << temp << ") didn't unregister itself as it should have." << std::~~endl;;
	77	orxout(internal_warning, context::pickups) << "Oops. In a PickupCarrier, while cleaning up, a Pickupable (&" << temp << ") didn't unregister itself as it should have." << endl;;
78	78	it++;
79	79	}
…	…
158	158	bool PickupCarrier::addPickup(Pickupable* pickup)
159	159	{
160		~~COUT(4) << "Adding Pickupable (&" << pickup << ") to PickupCarrier (&" << this << ")" << std::~~endl;
	160	orxout(verbose, context::pickups) << "Adding Pickupable (&" << pickup << ") to PickupCarrier (&" << this << ")" << endl;
161	161	return this->pickups_.insert(pickup).second;
162	162	}
…	…
172	172	bool PickupCarrier::removePickup(Pickupable* pickup)
173	173	{
174		~~COUT(4) << "Removing Pickupable (&" << pickup << ") from PickupCarrier (&" << this << ")" << std::~~endl;
	174	orxout(verbose, context::pickups) << "Removing Pickupable (&" << pickup << ") from PickupCarrier (&" << this << ")" << endl;
175	175	return this->pickups_.erase(pickup) == 1;
176	176	}

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

-                      r8464
+                      r8858
         if(this->pickupIdentifier_ != NULL)
+        {
             COUT(4) << "Pickupable (&" << this << ") destroyed." << std::endl;
+            orxout(verbose, context::pickups) << "Pickupable (&" << this << ") destroyed." << endl;
             this->pickupIdentifier_->destroy();
+        }
 …
             this->OrxonoxClass::destroy();
         else
             COUT(2) << this->getIdentifier()->getName() << " may be unsafe. " << std::endl;
+            orxout(internal_warning, context::pickups) << this->getIdentifier()->getName() << " may be unsafe. " << endl;
+    }
 …
             return false;
         COUT(4) << "Pickupable (&" << this << ") set to used " << used << "." << std::endl;
+        orxout(verbose, context::pickups) << "Pickupable (&" << this << ") set to used " << used << "." << endl;
         this->used_ = used;
 …
             return false;
         COUT(4) << "Target " << target->getName() << " added to Pickupable (" << this->getIdentifier()->getName() << ") (&" << this << ")." << std::endl;
+        orxout(verbose, context::pickups) << "Target " << target->getName() << " added to Pickupable (" << this->getIdentifier()->getName() << ") (&" << this << ")." << endl;
         this->targets_.push_back(target);
         return true;
 …
         if(!this->setCarrier(carrier))
+        {
             COUT(3) << "A Pickupable (&" << this << ") was trying to be added to a PickupCarrier, but was already present." << std::endl;
+            orxout(internal_warning, context::pickups) << "A Pickupable (&" << this << ") was trying to be added to a PickupCarrier, but was already present." << endl;
             return false;
+        }
         this->setPickedUp(true);
         COUT(4) << "Pickupable (&" << this << ") got picked up by a PickupCarrier (&" << carrier << ")." << std::endl;
+        orxout(verbose, context::pickups) << "Pickupable (&" << this << ") got picked up by a PickupCarrier (&" << carrier << ")." << endl;
         return true;
+    }
 …
         assert(this->getCarrier()); // The Carrier cannot be NULL at this point.
         if(!this->getCarrier()->removePickup(this)) //TODO Shouldn't this be a little later?
             COUT(2) << "Pickupable (&" << this << ", " << this->getIdentifier()->getName() << ") is being dropped, but it was not present in the PickupCarriers list of pickups." << std::endl;
         COUT(4) << "Pickupable (&" << this << ") got dropped up by a PickupCarrier (&" << this->getCarrier() << ")." << std::endl;
+            orxout(internal_warning, context::pickups) << "Pickupable (&" << this << ", " << this->getIdentifier()->getName() << ") is being dropped, but it was not present in the PickupCarriers list of pickups." << endl;
+        orxout(verbose, context::pickups) << "Pickupable (&" << this << ") got dropped up by a PickupCarrier (&" << this->getCarrier() << ")." << endl;
         this->setUsed(false);
         this->setPickedUp(false);
 …
             return false;
         COUT(4) << "Pickupable (&" << this << ") set to pickedUp " << pickedUp << "." << std::endl;
+        orxout(verbose, context::pickups) << "Pickupable (&" << this << ") set to pickedUp " << pickedUp << "." << endl;
         this->pickedUp_ = pickedUp;
 …
             return false;
         COUT(4) << "Pickupable (&" << this << ") changed Carrier (& " << carrier << ")." << std::endl;
+        orxout(verbose, context::pickups) << "Pickupable (&" << this << ") changed Carrier (& " << carrier << ")." << endl;
         if(carrier != NULL && tell)
 …
         Pickupable* pickup = dynamic_cast<Pickupable*>(item);
         COUT(4) << "Pickupable (&" << this << ") cloned. Clone is new Pickupable (&" << pickup << ")." << std::endl;
+        orxout(verbose, context::pickups) << "Pickupable (&" << this << ") cloned. Clone is new Pickupable (&" << pickup << ")." << endl;
         return pickup;
+    }

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

-                      r8738
+                      r8858
 //         else
 //         {
 //             CCOUT(2) << "Attempting to access the radar, but the radar is non existent." << std::endl;
+//             orxout(internal_warning) << "Attempting to access the radar, but the radar is non existent." << endl;
 //         }
 //         this->radarObjectDescription_ = str;
 …
         if (!object)
+        {
             COUT(1) << "Assertion: Every RadarViewable has to be assigned a WorldEntity pointer!" << std::endl;
+            orxout(user_error) << "Assertion: Every RadarViewable has to be assigned a WorldEntity pointer!" << endl;
             assert(0);
+        }

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

r8727	r8858
261	261	if(!this->engineTemplate_.empty())
262	262	{
263		~~COUT(4)<<"Loading an engine template: "<<this->engineTemplate_<<"\n"~~;
	263	orxout(verbose, context::templates) << "Loading an engine template: " << this->engineTemplate_ << endl;
264	264	Template *temp = Template::getTemplate(this->engineTemplate_);
265	265	if(temp)

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

-                      r8729
+                      r8858
 #include "util/DisplayStringConversions.h"
 #include "util/ScopedSingletonManager.h"
+#include "util/output/MemoryWriter.h"
 #include "core/CoreIncludes.h"
 #include "core/ConfigValueIncludes.h"
 …
+{
     const int LINES = 30;
     const float CHAR_WIDTH = 7.45f; // fix this please - determine the char-width dynamically
+    const float CHAR_WIDTH = 8.0f; // fix this please - determine the char-width dynamically
     SetConsoleCommand("InGameConsole", "openConsole", &InGameConsole::openConsole);
 …
         // Output buffering is not anymore needed. Not the best solution to do
         // this here, but there isn't much of another way.
         OutputHandler::getInstance().disableMemoryLog();
+        MemoryWriter::getInstance().disable();
+    }
 …
         this->consoleOverlayContainer_->setTop(-1.3f * this->relativeHeight);
         COUT(4) << "Info: InGameConsole initialized" << std::endl;
+        orxout(internal_info) << "InGameConsole initialized" << endl;
+    }
 …
         for (int i = LINES - 1; i > max; --i)
             this->print("", Shell::None, i, true);
+            this->print("", Shell::DebugOutput, i, true);
         for (int i = max; i >= 1; --i)
 …
     /**
+        @brief Called if only the last output-line has changed.
+    */
+    void InGameConsole::onlyLastLineChanged()
+    {
+        @brief Called if a new output-line was added.
+    */
+    void InGameConsole::lineAdded()
+    {
+        this->numLinesShifted_ = 0;
+        this->shiftLines();
         if (LINES > 1)
             this->print(this->shell_->getNewestLineIterator()->first, this->shell_->getNewestLineIterator()->second, 1);
+    }
-    /**
-        @brief Called if a new output-line was added.
-    */
-    void InGameConsole::lineAdded()
+    {
-        this->numLinesShifted_ = 0;
-        this->shiftLines();
-        this->onlyLastLineChanged();
+    }
 …
     void InGameConsole::executed()
+    {
         this->shell_->addOutput(this->shell_->getInput() + '\n', Shell::Command);
+        this->shell_->addOutput(this->shell_->getInput(), Shell::Command);
+    }
 …
         // now adjust the text lines...
         this->desiredTextWidth_ = static_cast<int>(this->windowW_ * this->relativeWidth) - 12;
+        this->desiredTextWidth_ = static_cast<int>(this->windowW_ * this->relativeWidth) - 24;
         if (LINES > 0)
 …
         switch (type)
+        {
+        case Shell::Error:   colourTop = ColourValue(0.95f, 0.25f, 0.25f, 1.00f);
+                          colourBottom = ColourValue(1.00f, 0.50f, 0.50f, 1.00f); break;
+        case Shell::Warning: colourTop = ColourValue(0.95f, 0.50f, 0.20f, 1.00f);
+                          colourBottom = ColourValue(1.00f, 0.70f, 0.50f, 1.00f); break;
+        case Shell::Info:    colourTop = ColourValue(0.50f, 0.50f, 0.95f, 1.00f);
+                          colourBottom = ColourValue(0.80f, 0.80f, 1.00f, 1.00f); break;
+        case Shell::Debug:   colourTop = ColourValue(0.65f, 0.48f, 0.44f, 1.00f);
+                          colourBottom = ColourValue(1.00f, 0.90f, 0.90f, 1.00f); break;
+        case Shell::Verbose: colourTop = ColourValue(0.40f, 0.20f, 0.40f, 1.00f);
+                          colourBottom = ColourValue(0.80f, 0.60f, 0.80f, 1.00f); break;
+        case Shell::Ultra:   colourTop = ColourValue(0.21f, 0.69f, 0.21f, 1.00f);
+                          colourBottom = ColourValue(0.80f, 1.00f, 0.80f, 1.00f); break;
+        case Shell::Command: colourTop = ColourValue(0.80f, 0.80f, 0.80f, 1.00f);
+                          colourBottom = ColourValue(0.90f, 0.90f, 0.90f, 0.90f); break;
+        case Shell::Hint:    colourTop = ColourValue(0.80f, 0.80f, 0.80f, 1.00f);
+                          colourBottom = ColourValue(0.90f, 0.90f, 0.90f, 1.00f); break;
+        case Shell::TDebug:  colourTop = ColourValue(0.90f, 0.00f, 0.90f, 1.00f);
+                          colourBottom = ColourValue(1.00f, 0.00f, 1.00f, 1.00f); break;
+        default:             colourTop = ColourValue(0.90f, 0.90f, 0.90f, 1.00f);
+                          colourBottom = ColourValue(1.00f, 1.00f, 1.00f, 1.00f); break;
+        }
+            case Shell::Message:
+            case Shell::DebugOutput:     colourTop = ColourValue(0.9f, 0.9f, 0.9f); break;
+            case Shell::UserError:       colourTop = ColourValue(0.9f, 0.0f, 0.0f); break;
+            case Shell::UserWarning:     colourTop = ColourValue(0.9f, 0.5f, 0.0f); break;
+            case Shell::UserStatus:      colourTop = ColourValue(0.0f, 0.9f, 0.0f); break;
+            case Shell::UserInfo:        colourTop = ColourValue(0.0f, 0.8f, 0.8f); break;
+            case Shell::InternalError:   colourTop = ColourValue(0.5f, 0.0f, 0.0f); break;
+            case Shell::InternalWarning: colourTop = ColourValue(0.5f, 0.2f, 0.0f); break;
+            case Shell::InternalStatus:  colourTop = ColourValue(0.0f, 0.5f, 0.0f); break;
+            case Shell::InternalInfo:    colourTop = ColourValue(0.0f, 0.4f, 0.4f); break;
+            case Shell::Verbose:         colourTop = ColourValue(0.3f, 0.3f, 0.9f); break;
+            case Shell::VerboseMore:     colourTop = ColourValue(0.2f, 0.2f, 0.7f); break;
+            case Shell::VerboseUltra:    colourTop = ColourValue(0.1f, 0.1f, 0.5f); break;
+            case Shell::Command:         colourTop = ColourValue(0.8f, 0.2f, 0.8f); break;
+            case Shell::Hint:            colourTop = ColourValue(0.4f, 0.0f, 0.4f); break;
+            case Shell::Input:           colourTop = ColourValue(0.9f, 0.9f, 0.9f); break;
+            default:                     colourTop = ColourValue(0.5f, 0.5f, 0.5f); break;
+        }
+        colourBottom = ColourValue(sqrt(colourTop.r), sqrt(colourTop.g), sqrt(colourTop.b));
         this->consoleOverlayTextAreas_[index]->setColourTop   (colourTop);

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

r7284	r8858
64	64
65	65	void linesChanged();
66		~~void onlyLastLineChanged();~~
67	66	void lineAdded();
68	67	void inputChanged();

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

r8706	r8858
147	147
148	148	if (OrxonoxOverlay::overlays_s.find(this->getName()) != OrxonoxOverlay::overlays_s.end())
149		~~COUT(1) << "Overlay names should be unique or you cannnot access them via console. Name: \"" << this->getName() << '"' << std::~~endl;
	149	orxout(internal_warning) << "Overlay names should be unique or you cannnot access them via console. Name: \"" << this->getName() << '"' << endl;
150	150
151	151	OrxonoxOverlay::overlays_s[this->getName()] = this;
…	…
362	362	{
363	363	overlay->hide();
364		~~COUT(4) << "HIDE " << name << std::~~endl;
	364	orxout(verbose, context::misc::overlays) << "HIDE " << name << endl;
365	365	}
366	366	else
367	367	{
368	368	overlay->show();
369		~~COUT(4) << "SHOW " << name << std::~~endl;
	369	orxout(verbose, context::misc::overlays) << "SHOW " << name << endl;
370	370	}
371	371	}

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

r7494	r8858
51	51
52	52	if(pickup == NULL)
53		~~COUT(1) << "Error, PickupIdentifier was created without a valid Pickupable." << std::~~endl;
	53	orxout(internal_error, context::pickups) << "PickupIdentifier was created without a valid Pickupable." << endl;
54	54
55	55	this->pickup_ = pickup;
…	…
83	83	if(!(this->parameters_.size() == identifier->parameters_.size()))
84	84	{
85		~~COUT(1) << "Something went wrong in PickupIdentifier!" << std::~~endl;
	85	orxout(internal_error, context::pickups) << "Something went wrong in PickupIdentifier!" << endl;
86	86	return this->parameters_.size()-identifier->parameters_.size();
87	87	}
…	…
93	93	if(identifier->parameters_.find(it->first) == identifier->parameters_.end())
94	94	{
95		~~COUT(1) << "Something went wrong in PickupIdentifier!" << std::~~endl;
	95	orxout(internal_error, context::pickups) << "Something went wrong in PickupIdentifier!" << endl;
96	96	return -1;
97	97	}
…	…
115	115	bool PickupIdentifier::addParameter(std::string & name, std::string & value)
116	116	{
117		~~COUT(4) << "PickupIdentifier " << name << ", " << value << std::~~endl;
	117	orxout(verbose, context::pickups) << "PickupIdentifier " << name << ", " << value << endl;
118	118
119	119	if(!(this->parameters_.find(name) == this->parameters_.end()))
120	120	{
121		~~COUT(4) << "Request for adding a parameter that already exists for the PickupIdentififer was denied. name: '" << name << "', value: '" << value << "'."<< std::~~endl;
	121	orxout(verbose, context::pickups) << "Request for adding a parameter that already exists for the PickupIdentififer was denied. name: '" << name << "', value: '" << value << "'."<< endl;
122	122	return false;
123	123	}

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

r8706	r8858
94	94	this->setSource(path);
95	95	else
96		~~COUT(3) << "Sound: " << this->ambientSource_ << ": Not a valid name! Ambient sound will not change." << std::~~endl;
	96	orxout(internal_warning, context::sound) << this->ambientSource_ << ": Not a valid name! Ambient sound will not change." << endl;
97	97	}
98	98	}

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

-                      r8729
+                      r8858
             alSourcePlay(this->audioSource_);
             if (int error = alGetError())
                 COUT(2) << "Sound: Error playing sound: " << SoundManager::getALErrorString(error) << std::endl;
+                orxout(internal_error, context::sound) << "Error playing sound: " << SoundManager::getALErrorString(error) << endl;
+        }
+    }
 …
         alSource3f(this->audioSource_, AL_DIRECTION, 0, 0, 0);
         if (ALint error = alGetError())
             COUT(2) << "Sound Warning: Setting source parameters to 0 failed: "
                     << SoundManager::getALErrorString(error) << std::endl;
+            orxout(internal_warning, context::sound) << "Setting source parameters to 0 failed: "
+                                                     << SoundManager::getALErrorString(error) << endl;
         assert(this->soundBuffer_ != NULL);
         alSourcei(this->audioSource_, AL_BUFFER, this->soundBuffer_->getBuffer());
         if (ALuint error = alGetError())
             COUT(1) << "Sound Error: Could not set buffer \"" << this->source_ << "\": " << SoundManager::getALErrorString(error) << std::endl;
+            orxout(internal_error, context::sound) << "Could not set buffer \"" << this->source_ << "\": " << SoundManager::getALErrorString(error) << endl;
+    }
 …
         this->volume_ = clamp(vol, 0.0f, 1.0f);
         if (this->volume_ != vol)
             COUT(2) << "Sound warning: volume out of range, clamping value." << std::endl;
+            orxout(internal_warning, context::sound) << "Volume out of range, clamping value." << endl;
         this->updateVolume();
+    }
 …
             alSourcef(this->audioSource_, AL_GAIN, volume);
             if (int error = alGetError())
                 COUT(2) << "Sound: Error setting volume to " << volume
                         << ": " << SoundManager::getALErrorString(error) << std::endl;
+                orxout(internal_error, context::sound) << "Error setting volume to " << volume
+                                                       << ": " << SoundManager::getALErrorString(error) << endl;
+        }
+    }
 …
         if (pitch > 2 || pitch < 0.5f)
+        {
             COUT(2) << "Sound warning: pitch out of range, cropping value." << std::endl;
+            orxout(internal_warning, context::sound) << "Pitch out of range, cropping value." << endl;
             pitch = pitch > 2.0f ? 2.0f : pitch;
             pitch = pitch < 0.5f ? 0.5f : pitch;
 …
             alSourcef(this->audioSource_, AL_PITCH, pitch);
             if (int error = alGetError())
                 COUT(2) << "Sound: Error setting pitch: " << SoundManager::getALErrorString(error) << std::endl;
+                orxout(internal_error, context::sound) << "Error setting pitch: " << SoundManager::getALErrorString(error) << endl;
+        }
+    }
 …
             if (ALuint error = alGetError())
+            {
                 COUT(1) << "Sound Error: Could not set buffer \"" << source << "\": " << SoundManager::getALErrorString(error) << std::endl;
+                orxout(internal_error, context::sound) << "Could not set buffer \"" << source << "\": " << SoundManager::getALErrorString(error) << endl;
                 return;
+            }
 …
             alSourcePlay(this->audioSource_);
             if (int error = alGetError())
                 COUT(2) << "Sound: Error playing sound: " << SoundManager::getALErrorString(error) << std::endl;
+                orxout(internal_error, context::sound) << "Error playing sound: " << SoundManager::getALErrorString(error) << endl;
             if (this->isPaused())
                 alSourcePause(this->audioSource_);

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

-                      r8351
+                      r8858
         if (fileInfo == NULL)
+        {
             COUT(2) << "Sound: Warning: Sound file '" << filename << "' not found" << std::endl;
+            orxout(internal_error, context::sound) << "Sound file '" << filename << "' not found" << endl;
             return;
+        }
 …
         if (ret < 0)
+        {
             COUT(2) << "Sound: libvorbisfile: File does not seem to be an Ogg Vorbis bitstream" << std::endl;
+            orxout(internal_error, context::sound) << "libvorbisfile: File does not seem to be an Ogg Vorbis bitstream" << endl;
             ov_clear(&vf);
             ThrowException(General, "Sound Error: Ogg file loader failed when opening the bitstream");
 …
             else if (ret < 0)
+            {
                 COUT(2) << "Sound: libvorbisfile: error reading the file" << std::endl;
+                orxout(internal_error, context::sound) << "libvorbisfile: error reading the file" << endl;
                 ov_clear(&vf);
                 ThrowException(General, "Sound Error: Ogg file loader failed when decoding the file");

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

-                      r8521
+                      r8858
         RegisterRootObject(SoundManager);
+        orxout(user_status) << "Loading sound" << endl;
         this->bDestructorCalled_ = false;
 …
         std::string renderDevice;
         SetConfigValue(renderDevice, std::string(device)).description("Sound device used for rendering");
         COUT(4) << "Sound: Available devices: ";
+        orxout(verbose, context::sound) << "Sound: Available devices: ";
         while (true)
+        {
             this->deviceNames_.push_back(devices);
             COUT(4) << '"' << devices << "\", ";
+            orxout(verbose, context::sound) << '"' << devices << "\", ";
             devices += strlen(devices) + 1;
             if (*devices == '\0')
                 break;
+        }
         COUT(4) << std::endl;
+        orxout(verbose, context::sound) << endl;
         // Open the selected device
         COUT(3) << "Sound: Opening device \"" << renderDevice << '\' << std::endl;
+        orxout(internal_info, context::sound) << "Sound: Opening device \"" << renderDevice << '\' << endl;
         this->device_ = alcOpenDevice(renderDevice.c_str());
 */
 …
         // Get some information about the sound
         if (const char* version = alGetString(AL_VERSION))
             COUT(4) << "Sound: --- OpenAL Version: " << version << std::endl;
+            orxout(internal_info, context::sound) << "Sound: --- OpenAL Version: " << version << endl;
         if (const char* vendor = alGetString(AL_VENDOR))
             COUT(4) << "Sound: --- OpenAL Vendor : " << vendor << std::endl;
+            orxout(internal_info, context::sound) << "Sound: --- OpenAL Vendor : " << vendor << endl;
         if (const char* types = alutGetMIMETypes(ALUT_LOADER_BUFFER))
             COUT(4) << "Sound: --- Supported MIME Types: " << types << std::endl;
+            orxout(internal_info, context::sound) << "Sound: --- Supported MIME Types: " << types << endl;
         else
             COUT(2) << "Sound Warning: MIME Type retrieval failed: " << alutGetErrorString(alutGetError()) << std::endl;
+            orxout(internal_warning, context::sound) << "MIME Type retrieval failed: " << alutGetErrorString(alutGetError()) << endl;
         this->mute_[SoundType::All]     = 1.0f;
 …
         resetPlaysSoundGuard.Dismiss();
         COUT(4) << "Sound: Initialisation complete" << std::endl;
+        orxout(internal_status, context::sound) << "Sound: Initialisation complete" << endl;
+    }
 …
         // If there are still used buffers around, well, that's just very bad...
         if (this->soundBuffers_.size() != this->effectsPool_.size())
             COUT(1) << "Sound Error: Some sound buffers are still in use but OpenAL is about to shut down. Fix this!" << std::endl;
+            orxout(internal_error, context::sound) << "Some sound buffers are still in use but OpenAL is about to shut down. Fix this!" << endl;
         // Empty buffer pool and buffer list
         this->effectsPool_.clear();
 …
         // There should not be any sources in use anymore
         if (!this->usedSoundSources_.empty())
             COUT(1) << "Sound Error: Some sound sources are still in use but OpenAL is about to shut down. Fix this!" << std::endl;
+            orxout(internal_error, context::sound) << "Some sound sources are still in use but OpenAL is about to shut down. Fix this!" << endl;
         while (!this->availableSoundSources_.empty())
+        {
 …
         // Relieve context to destroy it
         if (!alcMakeContextCurrent(NULL))
             COUT(1) << "Sound Error: Could not unset ALC context" << std::endl;
+            orxout(internal_error, context::sound) << "Could not unset ALC context" << endl;
         alcDestroyContext(this->context_);
         if (ALCenum error = alcGetError(this->device_))
+        {
             if (error == AL_INVALID_OPERATION)
                 COUT(1) << "Sound Error: Could not destroy ALC context because it is the current one" << std::endl;
+                orxout(internal_error, context::sound) << "Could not destroy ALC context because it is the current one" << endl;
             else
                 COUT(1) << "Sound Error: Could not destroy ALC context because it is invalid" << std::endl;
+                orxout(internal_error, context::sound) << "Could not destroy ALC context because it is invalid" << endl;
+        }
 #ifdef AL_VERSION_1_1
         if (!alcCloseDevice(this->device_))
             COUT(1) << "Sound Error: Could not destroy ALC device. This might be because there are still buffers in use!" << std::endl;
+            orxout(internal_error, context::sound) << "Could not destroy ALC device. This might be because there are still buffers in use!" << endl;
 #else
         alcCloseDevice(this->device_);
 #endif
         if (!alutExit())
             COUT(1) << "Sound Error: Closing ALUT failed: " << alutGetErrorString(alutGetError()) << std::endl;
+            orxout(internal_error, context::sound) << "Closing ALUT failed: " << alutGetErrorString(alutGetError()) << endl;
+    }
 …
         if (crossFadeStep_ <= 0.0 || crossFadeStep_ >= 1.0 )
+        {
             COUT(2) << "Sound warning: fade step out of range, ignoring change." << std::endl;
+            orxout(internal_warning, context::sound) << "Fade step out of range, ignoring change." << endl;
             ResetConfigValue(crossFadeStep_);
+        }
 …
         float clampedVolume = clamp(this->volume_[type], 0.0f, 1.0f);
         if (clampedVolume != this->volume_[type])
             COUT(2) << "Sound warning: Volume setting (" << type << ") out of range, clamping." << std::endl;
+            orxout(internal_warning, context::sound) << "Volume setting (" << type << ") out of range, clamping." << endl;
         this->updateVolume(type);
+    }
 …
         if (error == AL_INVALID_VALUE)
             // @TODO: Follow this constantly appearing, nerve-racking warning
             COUT(2) << "Sound: OpenAL: Invalid listener position" << std::endl;
+            orxout(internal_error, context::sound) << "OpenAL: Invalid listener position" << endl;
+    }
 …
         ALenum error = alGetError();
         if (error == AL_INVALID_VALUE)
             COUT(2) << "Sound: OpenAL: Invalid listener orientation" << std::endl;
+            orxout(internal_error, context::sound) << "OpenAL: Invalid listener orientation" << endl;
+    }
 …
                 if (it->first == newAmbient)
+                {
                     COUT(2) << "Sound warning: Will not play an AmbientSound twice." << std::endl;
+                    orxout(internal_warning, context::sound) << "Will not play an AmbientSound twice." << endl;
                     return;
+                }
 …
             catch (const std::exception& ex)
+            {
                 COUT(1) << ex.what() << std::endl;
+                orxout(internal_error, context::sound) << ex.what() << endl;
                 return buffer;
+            }
 …
             alDeleteSources(1, &this->availableSoundSources_.back());
             if (alGetError())
                 COUT(1) << "Sound Error: Failed to delete a source --> lost forever" << std::endl;
+                orxout(internal_error, context::sound) << "Failed to delete a source --> lost forever" << endl;
             this->availableSoundSources_.pop_back();
+        }

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

-                      r7163
+                      r8858
         if (ret < 0)
+        {
             COUT(2) << "Sound: libvorbisfile: File does not seem to be an Ogg Vorbis bitstream" << std::endl;
+            orxout(internal_error, context::sound) << "libvorbisfile: File does not seem to be an Ogg Vorbis bitstream" << endl;
             ov_clear(&vf);
             return;
 …
             else if (ret < 0)
+            {
                 COUT(2) << "Sound: libvorbisfile: error reading the file" << std::endl;
+                orxout(internal_error, context::sound) << "libvorbisfile: error reading the file" << endl;
                 ov_clear(&vf);
                 return;
 …
             alGetSourcei(audioSource, AL_BUFFERS_PROCESSED, &processed);
             if (ALint error = alGetError())
             COUT(2) << "Sound Warning: Couldn't get number of processed buffers: "
                     << SoundManager::getALErrorString(error) << std::endl;
+            orxout(internal_warning, context::sound) << "Couldn't get number of processed buffers: "
+                                                     << SoundManager::getALErrorString(error) << endl;
             if(processed > 0)
 …
                 alSourceUnqueueBuffers(audioSource, processed, buffers);
                 if (ALint error = alGetError())
                     COUT(2) << "Sound Warning: Couldn't unqueue buffers: "
                     << SoundManager::getALErrorString(error) << std::endl;
+                    orxout(internal_warning, context::sound) << "Couldn't unqueue buffers: "
+                                                             << SoundManager::getALErrorString(error) << endl;
                 for(int i = 0; i < processed; i++)
 …
                     else if (ret < 0)
+                    {
                         COUT(2) << "Sound: libvorbisfile: error reading the file" << std::endl;
+                        orxout(internal_error, context::sound) << "libvorbisfile: error reading the file" << endl;
                         ov_clear(&vf);
                         return;
 …
                 alSourceQueueBuffers(audioSource, processed, buffers);
                 if (ALint error = alGetError())
                     COUT(2) << "Sound Warning: Couldn't queue buffers: "
                     << SoundManager::getALErrorString(error) << std::endl;
+                    orxout(internal_warning, context::sound) << "Couldn't queue buffers: "
+                                                             << SoundManager::getALErrorString(error) << endl;
+            }
+        }

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

-                      r8351
+                      r8858
             ALenum error = alGetError();
             if (error == AL_INVALID_VALUE)
                 COUT(2) << "Sound: OpenAL: Invalid sound position" << std::endl;
+                orxout(internal_error, context::sound) << "OpenAL: Invalid sound position" << endl;
             const Vector3& vel = this->getVelocity();
 …
             error = alGetError();
             if (error == AL_INVALID_VALUE)
                 COUT(2) << "Sound: OpenAL: Invalid sound velocity" << std::endl;
+                orxout(internal_error, context::sound) << "OpenAL: Invalid sound velocity" << endl;
             const Vector3& direction = -this->getWorldOrientation().zAxis();
 …
             error = alGetError();
             if (error == AL_INVALID_VALUE)
                 COUT(2) << "Sound: OpenAL: Invalid sound direction" << std::endl;
+                orxout(internal_error, context::sound) << "OpenAL: Invalid sound direction" << endl;
+        }
+    }

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

-                      r8706
+                      r8858
             this->munitiontype_ = identifier;
         else
             COUT(2) << "Warning: No munition class defined in WeaponMode " << this->getName() << std::endl;
+            orxout(internal_warning) << "No munition class defined in WeaponMode " << this->getName() << endl;
         this->updateMunition();
+    }
 …
             Vector3 muzzleDirection;
             muzzleDirection = target - this->muzzlePosition_;
-//             COUT(0) << "muzzleDirection " << muzzleDirection << endl;
             this->muzzleOrientation_ = (this->weapon_->getWorldOrientation() * WorldEntity::FRONT).getRotationTo(muzzleDirection) * this->weapon_->getWorldOrientation();
+        }

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

r7284	r8858
61	61	catch (const std::exception& ex)
62	62	{
63		~~COUT(1) << "Error: Couln't load particle effect in BigExplosion: " << ex.what() << std::~~endl;
	63	orxout(internal_error) << "Couldn't load particle effect in BigExplosion: " << ex.what() << endl;
64	64	this->initZero();
65	65	}

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

r8706	r8858
457	457	}
458	458	else
459		~~COUT(2) << "Warning: ControllableEntity \"" << this->getName() << "\" already has a Controller." << std::~~endl;
	459	orxout(internal_warning) << "ControllableEntity \"" << this->getName() << "\" already has a Controller." << endl;
460	460	}
461	461

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

r7284	r8858
61	61	catch (const std::exception& ex)
62	62	{
63		~~COUT(1) << "Error: Couln't load particle effect in ExplosionChunk: " << ex.what() << std::~~endl;
	63	orxout(internal_error) << "Couldn't load particle effect in ExplosionChunk: " << ex.what() << endl;
64	64	this->fire_ = 0;
65	65	this->smoke_ = 0;

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

r8727	r8858
189	189	if (type == WorldEntity::Static)
190	190	{
191		~~CCOUT(1) << "Error: Cannot tell a MobileEntity to have static collision type! Ignoring." << std::~~endl;
	191	orxout(internal_warning) << "Cannot tell a MobileEntity to have static collision type! Ignoring." << endl;
192	192	assert(false); // Only in debug mode
193	193	return false;

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

r8706	r8858
48	48	this->getGametype()->registerSpawnPoint(this);
49	49	else
50		~~COUT(1) << "Error: SpawnPoint has no Gametype" << std::~~endl;
	50	orxout(internal_error) << "SpawnPoint has no Gametype" << endl;
51	51
52	52	this->setSyncMode(ObjectDirection::None);

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

r6417	r8858
63	63	if (this->addedToPhysicalWorld())
64	64	{
65		~~CCOUT(2) << "Warning: Attempting to change the position of a StaticEntity at physics run time. Ignoring change." << std::~~endl;
	65	orxout(internal_warning) << "Attempting to change the position of a StaticEntity at physics run time. Ignoring change." << endl;
66	66	return;
67	67	}
…	…
80	80	if (this->addedToPhysicalWorld())
81	81	{
82		~~CCOUT(2) << "Warning: Attempting to change the orientation of a StaticEntity at physics run time. Ignoring change." << std::~~endl;
	82	orxout(internal_warning) << "Attempting to change the orientation of a StaticEntity at physics run time. Ignoring change." << endl;
83	83	return;
84	84	}
…	…
97	97	if (type == WorldEntity::Kinematic \|\| type == WorldEntity::Dynamic)
98	98	{
99		~~CCOUT(1) << "Error: Cannot tell a StaticEntity to have kinematic or dynamic collision type! Ignoring." << std::~~endl;
	99	orxout(internal_warning) << "Cannot tell a StaticEntity to have kinematic or dynamic collision type! Ignoring." << endl;
100	100	assert(false); // Only in debug mode
101	101	return false;

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

r8706	r8858
95	95	this->collisionType_ = None;
96	96	this->collisionTypeSynchronised_ = None;
97		this->mass_ = 0;
	97	this->mass_ = 1.0f;
98	98	this->childrenMass_ = 0;
99	99	// Using bullet default values
…	…
311	311	this->collisionTypeSynchronised_ != None)
312	312	{
313		~~CCOUT(1) << "Error when collsion Type was received over network. Unknown enum value:" << this->collisionTypeSynchronised_ << std::~~endl;
	313	orxout(internal_error) << "Error when collsion Type was received over network. Unknown enum value:" << this->collisionTypeSynchronised_ << endl;
314	314	}
315	315	else if (this->collisionTypeSynchronised_ != collisionType_)
316	316	{
317	317	if (this->parent_)
318		~~CCOUT(2) << "Warning: Network connection tried to set the collision type of an attached WE. Ignoring." << std::~~endl;
	318	orxout(internal_warning) << "Network connection tried to set the collision type of an attached WE. Ignoring." << endl;
319	319	else
320	320	this->setCollisionType(this->collisionTypeSynchronised_);
…	…
373	373	if (object == this)
374	374	{
375		~~COUT(2) << "Warning: Can't attach a WorldEntity to itself." << std::~~endl;
	375	orxout(internal_warning) << "Can't attach a WorldEntity to itself." << endl;
376	376	return;
377	377	}
…	…
406	406	if (!newParent->hasPhysics())
407	407	{
408		~~COUT(2) << "Warning: Cannot attach a physical object to a non physical one." << std::~~endl;
	408	orxout(internal_warning) << " Cannot attach a physical object to a non physical one." << endl;
409	409	return false;
410	410	}
411	411	else if (this->isDynamic())
412	412	{
413		~~COUT(2) << "Warning: Cannot attach a dynamic object to a WorldEntity." << std::~~endl;
	413	orxout(internal_warning) << "Cannot attach a dynamic object to a WorldEntity." << endl;
414	414	return false;
415	415	}
416	416	else if (this->isKinematic() && newParent->isDynamic())
417	417	{
418		~~COUT(2) << "Warning: Cannot attach a kinematic object to a dynamic one." << std::~~endl;
	418	orxout(internal_warning) << "Cannot attach a kinematic object to a dynamic one." << endl;
419	419	return false;
420	420	}
421	421	else if (this->isKinematic())
422	422	{
423		~~COUT(2) << "Warning: Cannot attach a kinematic object to a static or kinematic one: Not yet implemented." << std::~~endl;
	423	orxout(internal_warning) << "Cannot attach a kinematic object to a static or kinematic one: Not yet implemented." << endl;
424	424	return false;
425	425	}
…	…
455	455	if (it == this->children_.end())
456	456	{
457		~~CCOUT(2) << "Warning: Cannot detach an object that is not a child." << std::~~endl;
	457	orxout(internal_warning) << "Cannot detach an object that is not a child." << endl;
458	458	return;
459	459	}
…	…
799	799	if (this->parent_)
800	800	{
801		~~CCOUT(2) << "Warning: Cannot set the collision type of a WorldEntity with a parent." << std::~~endl;
	801	orxout(internal_warning) << "Cannot set the collision type of a WorldEntity with a parent." << endl;
802	802	return;
803	803	}
…	…
822	822	if (!this->node_->getScale().positionEquals(Vector3(1, 1, 1), 0.001))
823	823	{
824		~~CCOUT(2) << "Warning: Cannot create a physical body if there is scaling applied to the node: Not yet implemented." << std::~~endl;
	824	orxout(internal_warning) << "Cannot create a physical body if there is scaling applied to the node: Not yet implemented." << endl;
825	825	return;
826	826	}
…	…
968	968	this->physicalBody_->setMassProps(0.0f, btVector3(0, 0, 0));
969	969	}
970		else if (~~(this->mass_ + this->childrenMass_)~~ == 0.0f)
	970	else if (totalMass == 0.0f)
971	971	{
972	972	// Use default values to avoid very large or very small values
973		~~CCOUT(4) << "Warning: Setting the internal physical mass to 1.0 because mass_ is 0.0" << std::~~endl;
	973	orxout(internal_warning) << "Setting the internal physical mass to 1.0 because mass_ is 0.0" << endl;
974	974	btVector3 inertia(0, 0, 0);
975	975	this->collisionShape_->calculateLocalInertia(1.0f, inertia);

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

r7184	r8858
132	132	if (type != WorldEntity::Dynamic)
133	133	{
134		~~CCOUT(1) << "Error: Cannot tell a FpsPlayer not to be dynamic! Ignoring." << std::~~endl;
	134	orxout(internal_warning) << "Cannot tell a FpsPlayer not to be dynamic! Ignoring." << endl;
135	135	assert(false); // Only in debug mode
136	136	return false;

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

r8727	r8858
145	145	if (type != WorldEntity::Dynamic)
146	146	{
147		~~CCOUT(1) << "Error: Cannot tell a SpaceShip not to be dynamic! Ignoring." << std::~~endl;
	147	orxout(internal_warning) << "Cannot tell a SpaceShip not to be dynamic! Ignoring." << endl;
148	148	assert(false); // Only in debug mode
149	149	return false;
…	…
507	507	if (camera == 0)
508	508	{
509		~~COUT(2) << "Failed to reset camera!"~~;
	509	orxout(internal_warning) << "Failed to reset camera!" << endl;
510	510	return;
511	511	}

Context Navigation

Legend: