Changeset 3280 for code/trunk/src

code/trunk

Property svn:mergeinfo changed
/code/branches/core4 (added) merged: 3235-3237,3245-3250,3253-3254,3260-3261,3265,3270

code/trunk/src/core/ArgumentCompletionFunctions.cc

-                      r3196
+                      r3280
 #include "util/Convert.h"
 #include "util/String.h"
+#include "util/StringUtils.h"
 #include "Identifier.h"
 #include "ConfigValueContainer.h"
 …
             for (std::list<unsigned int>::const_iterator it = threadnumbers.begin(); it != threadnumbers.end(); ++it)
                 threads.push_back(ArgumentCompletionListElement(getConvertedValue<unsigned int, std::string>(*it)));
+                threads.push_back(ArgumentCompletionListElement(multi_cast<std::string>(*it)));
             return threads;

code/trunk/src/core/BaseObject.cc

r3196	r3280
36	36	#include <tinyxml/tinyxml.h>
37	37
38		#include "util/String.h"
	38	#include "util/StringUtils.h"
39	39	#include "CoreIncludes.h"
40	40	#include "Event.h"

code/trunk/src/core/CMakeLists.txt

r3196	r3280
68	68	TOLUA_FILES
69	69	CommandExecutor.h
70		~~Game.h~~
71	70	LuaBind.h
72	71	DEFINE_SYMBOL

code/trunk/src/core/CommandEvaluation.cc

-                      r3196
+                      r3280
 #include "util/Debug.h"
 #include "util/String.h"
+#include "util/StringUtils.h"
 #include "ConsoleCommand.h"
 #include "Identifier.h"
 …
+    {
         this->initialize("");
         this->state_ = CS_Uninitialized;
+        this->state_ = CommandState::Uninitialized;
+    }
 …
         this->errorMessage_ = "";
         this->state_ = CS_Empty;
+        this->state_ = CommandState::Empty;
+    }
 …
             switch (this->state_)
+            {
                 case CS_Uninitialized:
                     break;
                 case CS_Empty:
                     break;
                 case CS_ShortcutOrIdentifier:
+                case CommandState::Uninitialized:
+                    break;
+                case CommandState::Empty:
+                    break;
+                case CommandState::ShortcutOrIdentifier:
                     if (this->function_)
+                    {
 …
                         return (this->command_ = this->functionclass_->getName() + " ");
                     break;
                 case CS_Function:
+                case CommandState::Function:
                     if (this->function_)
+                    {
 …
+                    }
                     break;
                 case CS_ParamPreparation:
                 case CS_Params:
+                case CommandState::ParamPreparation:
+                case CommandState::Params:
+                {
                     if (this->argument_ == "" && this->possibleArgument_ == "")
 …
                     break;
+                }
                 case CS_Finished:
                     break;
                 case CS_Error:
+                case CommandState::Finished:
+                    break;
+                case CommandState::Error:
                     break;
+            }
 …
         switch (this->state_)
+        {
             case CS_Uninitialized:
                 break;
             case CS_Empty:
             case CS_ShortcutOrIdentifier:
+            case CommandState::Uninitialized:
+                break;
+            case CommandState::Empty:
+            case CommandState::ShortcutOrIdentifier:
                 if (this->listOfPossibleFunctions_.size() == 0)
                     return CommandEvaluation::dump(this->listOfPossibleIdentifiers_);
 …
                     return (CommandEvaluation::dump(this->listOfPossibleFunctions_) + "\n" + CommandEvaluation::dump(this->listOfPossibleIdentifiers_));
                 break;
             case CS_Function:
+            case CommandState::Function:
                 return CommandEvaluation::dump(this->listOfPossibleFunctions_);
                 break;
             case CS_ParamPreparation:
             case CS_Params:
+            case CommandState::ParamPreparation:
+            case CommandState::Params:
                 if (this->listOfPossibleArguments_.size() > 0)
                     return CommandEvaluation::dump(this->listOfPossibleArguments_);
                 else
                     return CommandEvaluation::dump(this->function_);
             case CS_Finished:
+            case CommandState::Finished:
                 if (this->function_)
                     return CommandEvaluation::dump(this->function_);
                 break;
             case CS_Error:
+            case CommandState::Error:
                 return this->errorMessage_;
                 break;
 …
         for (unsigned int i = 0; i < MAX_FUNCTOR_ARGUMENTS; i++)
             this->param_[i] = MT_null;
+            this->param_[i] = MT_Type::Null;
         if (!this->isValid())
 …
             return this->param_[index];
         return MT_null;
+        return MT_Type::Null;
+    }
 …
             return this->function_->hasReturnvalue();
         return MT_null;
+        return MT_Type::Null;
+    }

code/trunk/src/core/CommandEvaluation.h

-                      r1747
+                      r3280
 namespace orxonox
+{
     enum CommandState
+    namespace CommandState
+    {
+        CS_Uninitialized,
+        CS_Empty,
+        CS_ShortcutOrIdentifier,
+        CS_Function,
+        CS_ParamPreparation,
+        CS_Params,
+        CS_Finished,
+        CS_Error
+    };
+        enum Value
+        {
+            Uninitialized,
+            Empty,
+            ShortcutOrIdentifier,
+            Function,
+            ParamPreparation,
+            Params,
+            Finished,
+            Error
+        };
+    }
     class _CoreExport CommandEvaluation
 …
             std::string errorMessage_;
             CommandState state_;
+            CommandState::Value state_;
             bool bEvaluatedParams_;

code/trunk/src/core/CommandExecutor.cc

r3196	r3280
30	30
31	31	#include "util/Debug.h"
32		#include "util/String.h"
	32	#include "util/StringUtils.h"
33	33	#include "ConsoleCommand.h"
34	34	#include "Identifier.h"
…	…
141	141	void CommandExecutor::parseIfNeeded(const std::string& command)
142	142	{
143		if (CommandExecutor::getEvaluation().state_ == CS_Uninitialized)
	143	if (CommandExecutor::getEvaluation().state_ == CommandState::Uninitialized)
144	144	{
145	145	CommandExecutor::parse(command);
…	…
169	169	switch (CommandExecutor::getEvaluation().state_)
170	170	{
171		case CS_Uninitialized:
	171	case CommandState::Uninitialized:
172	172	{
173	173	// Impossible
174	174	break;
175	175	}
176		case CS_Empty:
	176	case CommandState::Empty:
177	177	{
178	178	if (CommandExecutor::argumentsGiven() == 0)
…	…
184	184	else
185	185	{
186		CommandExecutor::getEvaluation().state_ = CS_ShortcutOrIdentifier;
	186	CommandExecutor::getEvaluation().state_ = CommandState::ShortcutOrIdentifier;
187	187	// Move on to next case
188	188	}
189	189	}
190		case CS_ShortcutOrIdentifier:
	190	case CommandState::ShortcutOrIdentifier:
191	191	{
192	192	if (CommandExecutor::argumentsGiven() > 1)
…	…
199	199	{
200	200	// It's a shortcut
201		CommandExecutor::getEvaluation().state_ = CS_ParamPreparation;
	201	CommandExecutor::getEvaluation().state_ = CommandState::ParamPreparation;
202	202	CommandExecutor::getEvaluation().functionclass_ = 0;
203	203	// Move on to next case
…	…
206	206	{
207	207	// It's a functionname
208		CommandExecutor::getEvaluation().state_ = CS_Function;
	208	CommandExecutor::getEvaluation().state_ = CommandState::Function;
209	209	CommandExecutor::getEvaluation().function_ = 0;
210	210	// Move on to next case
…	…
213	213	{
214	214	// The first argument is bad
215		CommandExecutor::getEvaluation().state_ = CS_Error;
	215	CommandExecutor::getEvaluation().state_ = CommandState::Error;
216	216	AddLanguageEntry("commandexecutorunknownfirstargument", "is not a shortcut nor a classname");
217	217	CommandExecutor::getEvaluation().errorMessage_ = "Error: " + CommandExecutor::getArgument(0) + " " + GetLocalisation("commandexecutorunknownfirstargument") + ".";
…	…
238	238	CommandExecutor::getEvaluation().bCommandChanged_ = true;
239	239	}
240		CommandExecutor::getEvaluation().state_ = CS_ParamPreparation;
	240	CommandExecutor::getEvaluation().state_ = CommandState::ParamPreparation;
241	241	CommandExecutor::getEvaluation().functionclass_ = 0;
242	242	CommandExecutor::getEvaluation().command_ = CommandExecutor::getEvaluation().function_->getName();
…	…
258	258	CommandExecutor::getEvaluation().bCommandChanged_ = true;
259	259	}
260		CommandExecutor::getEvaluation().state_ = CS_Function;
	260	CommandExecutor::getEvaluation().state_ = CommandState::Function;
261	261	CommandExecutor::getEvaluation().function_ = 0;
262	262	CommandExecutor::getEvaluation().command_ = CommandExecutor::getEvaluation().functionclass_->getName() + " ";
…	…
266	266	{
267	267	// No possibilities
268		CommandExecutor::getEvaluation().state_ = CS_Error;
	268	CommandExecutor::getEvaluation().state_ = CommandState::Error;
269	269	AddLanguageEntry("commandexecutorunknownfirstargumentstart", "There is no command or classname starting with");
270	270	CommandExecutor::getEvaluation().errorMessage_ = "Error: " + GetLocalisation("commandexecutorunknownfirstargumentstart") + " " + CommandExecutor::getArgument(0) + ".";
…	…
285	285	}
286	286	}
287		case CS_Function:
	287	case CommandState::Function:
288	288	{
289	289	if (CommandExecutor::getEvaluation().functionclass_)
…	…
298	298	{
299	299	// It's a function
300		CommandExecutor::getEvaluation().state_ = CS_ParamPreparation;
	300	CommandExecutor::getEvaluation().state_ = CommandState::ParamPreparation;
301	301	// Move on to next case
302	302	}
…	…
304	304	{
305	305	// The second argument is bad
306		CommandExecutor::getEvaluation().state_ = CS_Error;
	306	CommandExecutor::getEvaluation().state_ = CommandState::Error;
307	307	AddLanguageEntry("commandexecutorunknownsecondargument", "is not a function of");
308	308	CommandExecutor::getEvaluation().errorMessage_ = "Error: " + CommandExecutor::getArgument(1) + " " + GetLocalisation("commandexecutorunknownsecondargument") + " " + CommandExecutor::getEvaluation().functionclass_->getName() + ".";
…	…
326	326	CommandExecutor::getEvaluation().bCommandChanged_ = true;
327	327	}
328		CommandExecutor::getEvaluation().state_ = CS_ParamPreparation;
	328	CommandExecutor::getEvaluation().state_ = CommandState::ParamPreparation;
329	329	CommandExecutor::getEvaluation().command_ = CommandExecutor::getEvaluation().functionclass_->getName() + " " + CommandExecutor::getEvaluation().function_->getName();
330	330	if (CommandExecutor::getEvaluation().function_->getParamCount() > 0)
…	…
338	338	{
339	339	// No possibilities
340		CommandExecutor::getEvaluation().state_ = CS_Error;
	340	CommandExecutor::getEvaluation().state_ = CommandState::Error;
341	341	AddLanguageEntry("commandexecutorunknownsecondargumentstart", "has no function starting with");
342	342	CommandExecutor::getEvaluation().errorMessage_ = "Error: " + CommandExecutor::getEvaluation().functionclass_->getName() + " " + GetLocalisation("commandexecutorunknownsecondargumentstart") + " " + CommandExecutor::getArgument(1) + ".";
…	…
355	355	else
356	356	{
357		// There is no classname - move on to CS_ParamPreparation
358		}
359		}
360		case CS_ParamPreparation:
	357	// There is no classname - move on to CommandState::ParamPreparation
	358	}
	359	}
	360	case CommandState::ParamPreparation:
361	361	{
362	362	if (CommandExecutor::getEvaluation().function_->getParamCount() == 0 \|\| CommandExecutor::enoughArgumentsGiven(CommandExecutor::getEvaluation().function_))
363	363	{
364		CommandExecutor::getEvaluation().state_ = CS_Finished;
	364	CommandExecutor::getEvaluation().state_ = CommandState::Finished;
365	365	return;
366	366	}
…	…
372	372
373	373	CommandExecutor::createListOfPossibleArguments(CommandExecutor::getLastArgument(), CommandExecutor::getEvaluation().function_, argumentNumber);
374		CommandExecutor::getEvaluation().state_ = CS_Params;
	374	CommandExecutor::getEvaluation().state_ = CommandState::Params;
375	375
376	376	if (CommandExecutor::getEvaluation().bCommandChanged_)
…	…
381	381	}
382	382	}
383		case CS_Params:
	383	case CommandState::Params:
384	384	{
385	385	if (CommandExecutor::getEvaluation().listOfPossibleArguments_.size() == 1)
…	…
388	388	CommandExecutor::getEvaluation().argument_ = (*CommandExecutor::getEvaluation().listOfPossibleArguments_.begin()).getString();
389	389	CommandExecutor::getEvaluation().possibleArgument_ = (*CommandExecutor::getEvaluation().listOfPossibleArguments_.begin()).getString();
390		CommandExecutor::getEvaluation().state_ = CS_ParamPreparation;
	390	CommandExecutor::getEvaluation().state_ = CommandState::ParamPreparation;
391	391	return;
392	392	}
…	…
394	394	{
395	395	// The user tries something new - we let him do
396		CommandExecutor::getEvaluation().state_ = CS_ParamPreparation;
	396	CommandExecutor::getEvaluation().state_ = CommandState::ParamPreparation;
397	397	CommandExecutor::getEvaluation().argument_ = CommandExecutor::getLastArgument();
398	398	return;
…	…
409	409	CommandExecutor::getEvaluation().argument_ = CommandExecutor::getCommonBegin(CommandExecutor::getEvaluation().listOfPossibleArguments_);
410	410	CommandExecutor::getEvaluation().possibleArgument_ = CommandExecutor::getPossibleArgument(CommandExecutor::getLastArgument(), CommandExecutor::getEvaluation().function_, argumentNumber);
411		CommandExecutor::getEvaluation().state_ = CS_ParamPreparation;
	411	CommandExecutor::getEvaluation().state_ = CommandState::ParamPreparation;
412	412	return;
413	413	}
414	414	}
415		case CS_Finished:
	415	case CommandState::Finished:
416	416	{
417	417	// Nothing more to do
418	418	break;
419	419	}
420		case CS_Error:
	420	case CommandState::Error:
421	421	{
422	422	// Bad, very bad

code/trunk/src/core/CommandLine.cc

-                      r3196
+                      r3280
 #include "CommandLine.h"
+#include <algorithm>
+#include <sstream>
 #include <boost/filesystem.hpp>
 …
 #include "util/Debug.h"
 #include "util/Exception.h"
 #include "util/String.h"
+#include "util/StringUtils.h"
 #include "util/SubString.h"
 #include "Core.h"
 …
 namespace orxonox
+{
     SetCommandLineArgument(optionsFile, "start.ini").shortcut("o");
+    SetCommandLineOnlyArgument(optionsFile, "start.ini").shortcut("o");
     /**
 …
         so that you can have simple command line switches.
     */
+    void CommandLineArgument::parse(const std::string& value)
+    {
+        if (value_.getType() == MT_bool)
+    void CommandLineArgument::parse(const std::string& value, bool bParsingFile)
+    {
+        if (bParsingFile && this->bCommandLineOnly_)
+            ThrowException(Argument, "Command line argument '" + getName() + "' is not allowed in files.");
+        if (value_.getType() == MT_Type::Bool)
+        {
             // simulate command line switch
 …
+            }
             else
+            {
                 ThrowException(Argument, "Could not read command line argument '" + getName() + "'.");
+            }
+        }
         else
 …
         Vector of space separated strings.
     */
+    void CommandLine::_parse(const std::vector<std::string>& arguments)
+    {
+        // why this? See bFirstTimeParse_ declaration.
+        if (bFirstTimeParse_)
+        {
+            // first shove all the shortcuts in a map
+            for (std::map<std::string, CommandLineArgument*>::const_iterator it = cmdLineArgs_.begin();
+                it != cmdLineArgs_.end(); ++it)
+            {
+                OrxAssert(cmdLineArgsShortcut_.find(it->second->getShortcut()) == cmdLineArgsShortcut_.end(),
+                    "Cannot have two command line shortcut with the same name.");
+                if (it->second->getShortcut() != "")
+                    cmdLineArgsShortcut_[it->second->getShortcut()] = it->second;
+            }
+            bFirstTimeParse_ = false;
+        }
+        std::string name;
+        std::string shortcut;
+        std::string value;
+        for (unsigned int i = 0; i < arguments.size(); ++i)
+        {
+            if (arguments[i].size() != 0)
+            {
+                // sure not ""
+                if (arguments[i][0] == '-')
+    void CommandLine::_parse(const std::vector<std::string>& arguments, bool bParsingFile)
+    {
+        try
+        {
+            // why this? See bFirstTimeParse_ declaration.
+            if (bFirstTimeParse_)
+            {
+                // first shove all the shortcuts in a map
+                for (std::map<std::string, CommandLineArgument*>::const_iterator it = cmdLineArgs_.begin();
+                    it != cmdLineArgs_.end(); ++it)
+                {
+                    // start with "-"
+                    if (arguments[i].size() == 1)
+                    OrxAssert(cmdLineArgsShortcut_.find(it->second->getShortcut()) == cmdLineArgsShortcut_.end(),
+                        "Cannot have two command line shortcut with the same name.");
+                    if (it->second->getShortcut() != "")
+                        cmdLineArgsShortcut_[it->second->getShortcut()] = it->second;
+                }
+                bFirstTimeParse_ = false;
+            }
+            std::string name;
+            std::string shortcut;
+            std::string value;
+            for (unsigned int i = 0; i < arguments.size(); ++i)
+            {
+                if (arguments[i].size() != 0)
+                {
+                    // sure not ""
+                    if (arguments[i][0] == '-')
+                    {
+                        // argument[i] is "-", probably a minus sign
+                        value += "- ";
+                    }
+                    else if (arguments[i][1] <= 57 && arguments[i][1] >= 48)
+                    {
+                        // negative number as a value
+                        value += arguments[i] + " ";
+                        // start with "-"
+                        if (arguments[i].size() == 1)
+                        {
+                            // argument[i] is "-", probably a minus sign
+                            value += "- ";
+                        }
+                        else if (arguments[i][1] <= 57 && arguments[i][1] >= 48)
+                        {
+                            // negative number as a value
+                            value += arguments[i] + " ";
+                        }
+                        else
+                        {
+                            // can be shortcut or full name argument
+                            // save old data first
+                            value = removeTrailingWhitespaces(value);
+                            if (name != "")
+                            {
+                                checkFullArgument(name, value, bParsingFile);
+                                name = "";
+                                assert(shortcut == "");
+                            }
+                            else if (shortcut != "")
+                            {
+                                checkShortcut(shortcut, value, bParsingFile);
+                                shortcut = "";
+                                assert(name == "");
+                            }
+                            if (arguments[i][1] == '-')
+                            {
+                                // full name argument with "--name"
+                                name = arguments[i].substr(2);
+                            }
+                            else
+                            {
+                                // shortcut with "-s"
+                                shortcut = arguments[i].substr(1);
+                            }
+                            // reset value string
+                            value = "";
+                        }
+                    }
                     else
+                    {
+                        // can be shortcut or full name argument
+                        // save old data first
+                        value = removeTrailingWhitespaces(value);
+                        if (name != "")
+                        // value string
+                        if (name == "" && shortcut == "")
+                        {
+                            checkFullArgument(name, value);
+                            name = "";
+                            assert(shortcut == "");
+                            ThrowException(Argument, "Expected \"-\" or \"-\" in command line arguments.\n");
+                        }
+                        else if (shortcut != "")
+                        {
+                            checkShortcut(shortcut, value);
+                            shortcut = "";
+                            assert(name == "");
+                        }
+                        if (arguments[i][1] == '-')
+                        {
+                            // full name argument with "--name"
+                            name = arguments[i].substr(2);
+                        }
+                        else
+                        {
+                            // shortcut with "-s"
+                            shortcut = arguments[i].substr(1);
+                        }
+                        // reset value string
+                        value = "";
+                        // Concatenate strings as long as there's no new argument by "-" or "--"
+                        value += arguments[i] + ' ';
+                    }
+                }
+                else
+                {
+                    // value string
+                    if (name == "" && shortcut == "")
+                    {
+                        ThrowException(Argument, "Expected \"-\" or \"-\" in command line arguments.\n");
+                    }
+                    // Concatenate strings as long as there's no new argument by "-" or "--"
+                    value += arguments[i] + ' ';
+                }
+            }
+        }
+        // parse last argument
+        value = removeTrailingWhitespaces(value);
+        if (name != "")
+        {
+            checkFullArgument(name, value);
+            assert(shortcut == "");
+        }
+        else if (shortcut != "")
+        {
+            checkShortcut(shortcut, value);
+            assert(name == "");
+            }
+            // parse last argument
+            value = removeTrailingWhitespaces(value);
+            if (name != "")
+            {
+                checkFullArgument(name, value, bParsingFile);
+                assert(shortcut == "");
+            }
+            else if (shortcut != "")
+            {
+                checkShortcut(shortcut, value, bParsingFile);
+                assert(name == "");
+            }
+        }
+        catch (const ArgumentException& ex)
+        {
+            COUT(0) << "Could not parse command line (including additional files): " << ex.what() << std::endl;
+            COUT(0) << CommandLine::getUsageInformation() << std::endl;
+            throw GeneralException("");
+        }
+    }
 …
         String containing the value
     */
     void CommandLine::checkFullArgument(const std::string& name, const std::string& value)
+    void CommandLine::checkFullArgument(const std::string& name, const std::string& value, bool bParsingFile)
+    {
         std::map<std::string, CommandLineArgument*>::const_iterator it = cmdLineArgs_.find(name);
 …
             ThrowException(Argument, "Command line argument '" + name + "' does not exist.");
         it->second->parse(value);
+        it->second->parse(value, bParsingFile);
+    }
 …
         String containing the value
     */
     void CommandLine::checkShortcut(const std::string& shortcut, const std::string& value)
+    void CommandLine::checkShortcut(const std::string& shortcut, const std::string& value, bool bParsingFile)
+    {
         std::map<std::string, CommandLineArgument*>::const_iterator it = cmdLineArgsShortcut_.find(shortcut);
 …
             ThrowException(Argument, "Command line shortcut '" + shortcut + "' does not exist.");
         it->second->parse(value);
+        it->second->parse(value, bParsingFile);
+    }
     std::string CommandLine::getUsageInformation()
+    {
+        CommandLine* inst = &_getInstance();
+        std::string infoStr;
+        for (std::map<std::string, CommandLineArgument*>::const_iterator it = inst->cmdLineArgs_.begin();
+            it != inst->cmdLineArgs_.end(); ++it)
+        {
+            infoStr += "[--" + it->second->getName() + " " + it->second->getInformation() + "] ";
+        }
+        return infoStr;
+        CommandLine& inst = _getInstance();
+        std::ostringstream infoStr;
+        // determine maximum name size
+        size_t maxNameSize = 0;
+        for (std::map<std::string, CommandLineArgument*>::const_iterator it = inst.cmdLineArgs_.begin();
+            it != inst.cmdLineArgs_.end(); ++it)
+        {
+            maxNameSize = std::max(it->second->getName().size(), maxNameSize);
+        }
+        infoStr << "Usage: orxonox [options]" << std::endl;
+        infoStr << "Available options:" << std::endl;
+        for (std::map<std::string, CommandLineArgument*>::const_iterator it = inst.cmdLineArgs_.begin();
+            it != inst.cmdLineArgs_.end(); ++it)
+        {
+            if (it->second->getShortcut() != "")
+                infoStr << " [-" << it->second->getShortcut() << "] ";
+            else
+                infoStr << "      ";
+            infoStr << "--" << it->second->getName() << " ";
+            if (it->second->getValue().getType() != MT_Type::Bool)
+                infoStr << "ARG ";
+            else
+                infoStr << "    ";
+            // fill with the necessary amount of blanks
+            infoStr << std::string(maxNameSize - it->second->getName().size(), ' ');
+            infoStr << ": " << it->second->getInformation();
+            infoStr << std::endl;
+        }
+        return infoStr.str();
+    }
 …
     /**
     @brief
+        Parses both command line and start.ini for CommandLineArguments.
+    */
+    void CommandLine::_parseAll(int argc, char** argv)
+    {
+        // parse command line first
+        Parses only the command line for CommandLineArguments.
+    */
+    void CommandLine::_parseCommandLine(int argc, char** argv)
+    {
         std::vector<std::string> args;
         for (int i = 1; i < argc; ++i)
             args.push_back(argv[i]);
+        this->_parse(args);
+        this->_parse(args, false);
+    }
+    /**
+    @brief
+        Parses start.ini (or the file specified with --optionsFile) for CommandLineArguments.
+    */
+    void CommandLine::_parseFile()
+    {
         std::string filename = CommandLine::getValue("optionsFile").getString();
         boost::filesystem::path filepath(Core::getConfigPath() / filename);
 …
         std::ifstream file;
         file.open(filepath.string().c_str());
         args.clear();
+        std::vector<std::string> args;
         if (file)
+        {
 …
+        }
+        try
+        {
+            _parse(args);
+        }
+        catch (orxonox::ArgumentException& ex)
+        {
+            COUT(1) << "An Exception occured while parsing " << filename << std::endl;
+            throw(ex);
+        }
+        _parse(args, true);
+    }
+}

code/trunk/src/core/CommandLine.h

-                      r3196
+                      r3280
 #define SetCommandLineArgument(name, defaultValue) \
     orxonox::CommandLineArgument& CmdArgumentDummyBoolVar##name \
+    = orxonox::CommandLine::addArgument(#name, defaultValue)
+    = orxonox::CommandLine::addArgument(#name, defaultValue, false)
+#define SetCommandLineOnlyArgument(name, defaultValue) \
+    orxonox::CommandLineArgument& CmdArgumentDummyBoolVar##name \
+    = orxonox::CommandLine::addArgument(#name, defaultValue, true)
 #define SetCommandLineSwitch(name) \
     orxonox::CommandLineArgument& CmdArgumentDummyBoolVar##name \
+    = orxonox::CommandLine::addArgument(#name, false)
+    = orxonox::CommandLine::addArgument(#name, false, false)
+#define SetCommandLineOnlySwitch(name) \
+    orxonox::CommandLineArgument& CmdArgumentDummyBoolVar##name \
+    = orxonox::CommandLine::addArgument(#name, false, true)
 …
         //! Returns the shortcut (example: "-p 22" for "--port 22") of the argument.
         //! Evaluates to "" if none there is none.
+        //! Evaluates to "" if there is none.
         const std::string& getShortcut() const { return shortcut_; }
         //! Sets the shortcut for the argument
 …
     private:
         //! Constructor initialises both value_ and defaultValue_ with defaultValue.
         CommandLineArgument(const std::string& name, const MultiType& defaultValue)
+        CommandLineArgument(const std::string& name, const MultiType& defaultValue, bool bCommandLineOnly)
             : bHasDefaultValue_(true)
             , name_(name)
             , value_(defaultValue)
             , defaultValue_(defaultValue)
+            , bCommandLineOnly_(bCommandLineOnly)
         { }
 …
         //! Parses the value string of a command line argument.
         void parse(const std::string& value);
+        void parse(const std::string& value, bool bParsingFile);
         //! Tells whether the value has been changed by the command line.
 …
         std::string usageInformation_; //!< Tells about the usage of this parameter
+        MultiType value_;            //!< The actual value
+        MultiType defaultValue_;     //!< Default value. Should not be changed.
+        MultiType   value_;            //!< The actual value
+        MultiType   defaultValue_;     //!< Default value. Should not be changed.
+        bool        bCommandLineOnly_; //!< Whether you cannot specify the value in a text file
     };
 …
         //! Parse redirection to internal member method.
+        static void parseAll(int argc, char** argv) { _getInstance()._parseAll(argc, argv); }
+        static void parseCommandLine(int argc, char** argv) { _getInstance()._parseCommandLine(argc, argv); }
+        static void parseFile() { _getInstance()._parseFile(); }
         static std::string getUsageInformation();
 …
         { return getArgument(name)->getValue(); }
         template <class T>
         static CommandLineArgument& addArgument(const std::string& name, T defaultValue);
+        static CommandLineArgument& addArgument(const std::string& name, T defaultValue, bool bCommandLineOnly);
         static bool existsArgument(const std::string& name)
 …
         static CommandLine& _getInstance();
+        void _parseAll(int argc, char** argv);
+        void _parse(const std::vector<std::string>& arguments);
+        void checkFullArgument(const std::string& name, const std::string& value);
+        void checkShortcut(const std::string& shortcut, const std::string& value);
+        void _parseCommandLine(int argc, char** argv);
+        void _parseFile();
+        void _parse(const std::vector<std::string>& arguments, bool bParsingFile);
+        void checkFullArgument(const std::string& name, const std::string& value, bool bParsingFile);
+        void checkShortcut(const std::string& shortcut, const std::string& value, bool bParsingFile);
         /**
 …
     */
     template <class T>
     CommandLineArgument& CommandLine::addArgument(const std::string& name, T defaultValue)
+    CommandLineArgument& CommandLine::addArgument(const std::string& name, T defaultValue, bool bCommandLineOnly)
+    {
         OrxAssert(!_getInstance().existsArgument(name),
             "Cannot add a command line argument with name '" + name + "' twice.");
+        return *(_getInstance().cmdLineArgs_[name] = new CommandLineArgument(name, defaultValue));
+        OrxAssert(MultiType(defaultValue).getType() != MT_Type::Bool || MultiType(defaultValue).getBool() != true,
+               "Boolean command line arguments with positive default values are not supported." << std::endl
+            << "Please use SetCommandLineSwitch and adjust your argument: " << name);
+        return *(_getInstance().cmdLineArgs_[name] = new CommandLineArgument(name, defaultValue, bCommandLineOnly));
+    }
+}

code/trunk/src/core/ConfigFileManager.cc

-                      r3198
+                      r3280
 #include "util/Convert.h"
 #include "util/Math.h"
 #include "util/String.h"
+#include "util/StringUtils.h"
 #include "ConsoleCommand.h"
 #include "ConfigValueContainer.h"
 …
+    {
         if (this->additionalComment_ == "" || this->additionalComment_.size() == 0)
             return (this->name_ + "[" + getConvertedValue<unsigned int, std::string>(this->index_, "0") + "]" + "=" + this->value_);
         else
             return (this->name_ + "[" + getConvertedValue<unsigned int, std::string>(this->index_, "0") + "]=" + this->value_ + " " + this->additionalComment_);
+            return (this->name_ + "[" + multi_cast<std::string>(this->index_) + "]" + "=" + this->value_);
+        else
+            return (this->name_ + "[" + multi_cast<std::string>(this->index_) + "]=" + this->value_ + " " + this->additionalComment_);
+    }

code/trunk/src/core/ConfigValueContainer.cc

r3196	r3280
78	78	for (unsigned int i = 0; i < this->valueVector_.size(); i++)
79	79	{
80		ConfigFileManager::getInstance().getValue(this->type_, this->sectionname_, this->varname_, i, this->valueVector_[i], this->value_.isType(MT_string));
	80	ConfigFileManager::getInstance().getValue(this->type_, this->sectionname_, this->varname_, i, this->valueVector_[i], this->value_.isType(MT_Type::String));
81	81	this->defvalueStringVector_.push_back(this->valueVector_[i]);
82	82	}
…	…
109	109	if (this->tset(input))
110	110	{
111		ConfigFileManager::getInstance().setValue(this->type_, this->sectionname_, this->varname_, input, this->value_.isType(MT_string));
	111	ConfigFileManager::getInstance().setValue(this->type_, this->sectionname_, this->varname_, input, this->value_.isType(MT_Type::String));
112	112	return true;
113	113	}
…	…
128	128	if (this->tset(index, input))
129	129	{
130		ConfigFileManager::getInstance().setValue(this->type_, this->sectionname_, this->varname_, index, input, this->value_.isType(MT_string));
	130	ConfigFileManager::getInstance().setValue(this->type_, this->sectionname_, this->varname_, index, input, this->value_.isType(MT_Type::String));
131	131	return true;
132	132	}
…	…
228	228	this->valueVector_.erase(this->valueVector_.begin() + index);
229	229	for (unsigned int i = index; i < this->valueVector_.size(); i++)
230		ConfigFileManager::getInstance().setValue(this->type_, this->sectionname_, this->varname_, i, this->valueVector_[i], this->value_.isType(MT_string));
	230	ConfigFileManager::getInstance().setValue(this->type_, this->sectionname_, this->varname_, i, this->valueVector_[i], this->value_.isType(MT_Type::String));
231	231	ConfigFileManager::getInstance().deleteVectorEntries(this->type_, this->sectionname_, this->varname_, this->valueVector_.size());
232	232
…	…
264	264	{
265	265	if (!this->bIsVector_)
266		this->value_ = ConfigFileManager::getInstance().getValue(this->type_, this->sectionname_, this->varname_, this->defvalueString_, this->value_.isType(MT_string));
	266	this->value_ = ConfigFileManager::getInstance().getValue(this->type_, this->sectionname_, this->varname_, this->defvalueString_, this->value_.isType(MT_Type::String));
267	267	else
268	268	{
…	…
273	273	if (i < this->defvalueStringVector_.size())
274	274	{
275		this->value_ = ConfigFileManager::getInstance().getValue(this->type_, this->sectionname_, this->varname_, i, this->defvalueStringVector_[i], this->value_.isType(MT_string));
	275	this->value_ = ConfigFileManager::getInstance().getValue(this->type_, this->sectionname_, this->varname_, i, this->defvalueStringVector_[i], this->value_.isType(MT_Type::String));
276	276	}
277	277	else
278	278	{
279		this->value_ = ConfigFileManager::getInstance().getValue(this->type_, this->sectionname_, this->varname_, i, MultiType(), this->value_.isType(MT_string));
	279	this->value_ = ConfigFileManager::getInstance().getValue(this->type_, this->sectionname_, this->varname_, i, MultiType(), this->value_.isType(MT_Type::String));
280	280	}
281	281

code/trunk/src/core/ConfigValueIncludes.h

-                      r2171
+                      r3280
     if (!container##varname) \
     { \
         container##varname = new orxonox::ConfigValueContainer(ConfigFileType::Settings, identifier##varname, identifier##varname->getName(), #varname, defvalue, varname); \
+        container##varname = new orxonox::ConfigValueContainer(type, identifier##varname, identifier##varname->getName(), #varname, defvalue, varname); \
         identifier##varname->addConfigValueContainer(#varname, container##varname); \
     } \
 …
     if (!container##varname) \
     { \
         container##varname = new orxonox::ConfigValueContainer(ConfigFileType::Settings, identifier##varname, identifier##varname->getName(), #varname, defvalue); \
+        container##varname = new orxonox::ConfigValueContainer(type, identifier##varname, identifier##varname->getName(), #varname, defvalue); \
         identifier##varname->addConfigValueContainer(#varname, container##varname); \
     } \

code/trunk/src/core/ConsoleCommand.h

-                      r3196
+                      r3280
     namespace AccessLevel
+    {
         enum Level
+        enum Value
+        {
             None,
 …
                 { this->Executor::setDefaultValue(index, param); return (*this); }
             inline ConsoleCommand& accessLevel(AccessLevel::Level level)
+            inline ConsoleCommand& accessLevel(AccessLevel::Value level)
                 { this->accessLevel_ = level; return (*this); }
             inline AccessLevel::Level getAccessLevel() const
+            inline AccessLevel::Value getAccessLevel() const
                 { return this->accessLevel_; }
 …
+            }
             inline ConsoleCommand& keybindMode(KeybindMode::Enum mode)
+            inline ConsoleCommand& keybindMode(KeybindMode::Value mode)
                 { this->keybindMode_ = mode; return *this; }
             inline KeybindMode::Enum getKeybindMode() const
+            inline KeybindMode::Value getKeybindMode() const
                 { return this->keybindMode_; }
 …
         private:
             AccessLevel::Level accessLevel_;
+            AccessLevel::Value accessLevel_;
             ArgumentCompleter* argumentCompleter_[5];
             ArgumentCompletionList argumentList_;
             KeybindMode::Enum keybindMode_;
+            KeybindMode::Value keybindMode_;
             int inputConfiguredParam_;
     };

code/trunk/src/core/Core.cc

-                      r3214
+                      r3280
 namespace orxonox
+{
-    //! Path to the parent directory of the ones above if program was installed with relativ pahts
-    static boost::filesystem::path rootPath_g;
-    static boost::filesystem::path executablePath_g;            //!< Path to the executable
-    static boost::filesystem::path mediaPath_g;                 //!< Path to the media file folder
-    static boost::filesystem::path configPath_g;                //!< Path to the config file folder
-    static boost::filesystem::path logPath_g;                   //!< Path to the log file folder
     //! Static pointer to the singleton
     Core* Core::singletonRef_s  = 0;
+    SetCommandLineArgument(mediaPath, "").information("PATH");
+    SetCommandLineArgument(writingPathSuffix, "").information("DIR");
+    SetCommandLineArgument(settingsFile, "orxonox.ini");
+    SetCommandLineArgument(limitToCPU, 0).information("0: off | #cpu");
+    Core::Core()
+    {
+        RegisterRootObject(Core);
+        assert(Core::singletonRef_s == 0);
+    SetCommandLineArgument(mediaPath, "").information("Path to the media/data files");
+    SetCommandLineOnlyArgument(writingPathSuffix, "").information("Additional subfolder for config and log files");
+    SetCommandLineArgument(settingsFile, "orxonox.ini").information("THE configuration file");
+#ifdef ORXONOX_PLATFORM_WINDOWS
+    SetCommandLineArgument(limitToCPU, 0).information("Limits the program to one cpu/core (1, 2, 3, etc.). 0 turns it off (default)");
+#endif
+    /**
+    @brief
+        Helper class for the Core singleton: we cannot derive
+        Core from OrxonoxClass because we need to handle the Identifier
+        destruction in the Core destructor.
+    */
+    class CoreConfiguration : public OrxonoxClass
+    {
+    public:
+        CoreConfiguration()
+        {
+        }
+        void initialise()
+        {
+            RegisterRootObject(CoreConfiguration);
+            this->setConfigValues();
+            // Possible media path override by the command line
+            if (!CommandLine::getArgument("mediaPath")->hasDefaultValue())
+                tsetMediaPath(CommandLine::getValue("mediaPath"));
+        }
+        /**
+            @brief Function to collect the SetConfigValue-macro calls.
+        */
+        void setConfigValues()
+        {
+#ifdef NDEBUG
+            const unsigned int defaultLevelConsole = 1;
+            const unsigned int defaultLevelLogfile = 3;
+            const unsigned int defaultLevelShell   = 1;
+#else
+            const unsigned int defaultLevelConsole = 3;
+            const unsigned int defaultLevelLogfile = 4;
+            const unsigned int defaultLevelShell   = 3;
+#endif
+            SetConfigValue(softDebugLevelConsole_, defaultLevelConsole)
+                .description("The maximal level of debug output shown in the console")
+                .callback(this, &CoreConfiguration::debugLevelChanged);
+            SetConfigValue(softDebugLevelLogfile_, defaultLevelLogfile)
+                .description("The maximal level of debug output shown in the logfile")
+                .callback(this, &CoreConfiguration::debugLevelChanged);
+            SetConfigValue(softDebugLevelShell_, defaultLevelShell)
+                .description("The maximal level of debug output shown in the ingame shell")
+                .callback(this, &CoreConfiguration::debugLevelChanged);
+            SetConfigValue(language_, Language::getLanguage().defaultLanguage_)
+                .description("The language of the ingame text")
+                .callback(this, &CoreConfiguration::languageChanged);
+            SetConfigValue(bInitializeRandomNumberGenerator_, true)
+                .description("If true, all random actions are different each time you start the game")
+                .callback(this, &CoreConfiguration::initializeRandomNumberGenerator);
+            SetConfigValue(mediaPathString_, mediaPath_.string())
+                .description("Relative path to the game data.")
+                .callback(this, &CoreConfiguration::mediaPathChanged);
+        }
+        /**
+            @brief Callback function if the debug level has changed.
+        */
+        void debugLevelChanged()
+        {
+            // softDebugLevel_ is the maximum of the 3 variables
+            this->softDebugLevel_ = this->softDebugLevelConsole_;
+            if (this->softDebugLevelLogfile_ > this->softDebugLevel_)
+                this->softDebugLevel_ = this->softDebugLevelLogfile_;
+            if (this->softDebugLevelShell_ > this->softDebugLevel_)
+                this->softDebugLevel_ = this->softDebugLevelShell_;
+            OutputHandler::setSoftDebugLevel(OutputHandler::LD_All,     this->softDebugLevel_);
+            OutputHandler::setSoftDebugLevel(OutputHandler::LD_Console, this->softDebugLevelConsole_);
+            OutputHandler::setSoftDebugLevel(OutputHandler::LD_Logfile, this->softDebugLevelLogfile_);
+            OutputHandler::setSoftDebugLevel(OutputHandler::LD_Shell,   this->softDebugLevelShell_);
+        }
+        /**
+            @brief Callback function if the language has changed.
+        */
+        void languageChanged()
+        {
+            // Read the translation file after the language was configured
+            Language::getLanguage().readTranslatedLanguageFile();
+        }
+        /**
+        @brief
+            Callback function if the media path has changed.
+        */
+        void mediaPathChanged()
+        {
+            mediaPath_ = boost::filesystem::path(this->mediaPathString_);
+        }
+        /**
+            @brief Sets the language in the config-file back to the default.
+        */
+        void resetLanguage()
+        {
+            ResetConfigValue(language_);
+        }
+        /**
+        @brief
+            Temporary sets the media path
+        @param path
+            The new media path
+        */
+        void tsetMediaPath(const std::string& path)
+        {
+            ModifyConfigValue(mediaPathString_, tset, path);
+        }
+        void initializeRandomNumberGenerator()
+        {
+            static bool bInitialized = false;
+            if (!bInitialized && this->bInitializeRandomNumberGenerator_)
+            {
+                srand(static_cast<unsigned int>(time(0)));
+                rand();
+                bInitialized = true;
+            }
+        }
+        int softDebugLevel_;                            //!< The debug level
+        int softDebugLevelConsole_;                     //!< The debug level for the console
+        int softDebugLevelLogfile_;                     //!< The debug level for the logfile
+        int softDebugLevelShell_;                       //!< The debug level for the ingame shell
+        std::string language_;                          //!< The language
+        bool bInitializeRandomNumberGenerator_;         //!< If true, srand(time(0)) is called
+        std::string mediaPathString_;                   //!< Path to the data/media file folder as string
+        //! Path to the parent directory of the ones above if program was installed with relativ pahts
+        boost::filesystem::path rootPath_;
+        boost::filesystem::path executablePath_;        //!< Path to the executable
+        boost::filesystem::path mediaPath_;             //!< Path to the media file folder
+        boost::filesystem::path configPath_;            //!< Path to the config file folder
+        boost::filesystem::path logPath_;               //!< Path to the log file folder
+    };
+    Core::Core(int argc, char** argv)
+    {
+        if (singletonRef_s != 0)
+        {
+            COUT(0) << "Error: The Core singleton cannot be recreated! Shutting down." << std::endl;
+            abort();
+        }
         Core::singletonRef_s = this;
+    }
+    void Core::initialise(int argc, char** argv)
+    {
+        // Parse command line arguments fist
+        try
+        {
+            CommandLine::parseAll(argc, argv);
+        }
+        catch (ArgumentException& ex)
+        {
+            COUT(1) << ex.what() << std::endl;
+            COUT(0) << "Usage:" << std::endl << "orxonox " << CommandLine::getUsageInformation() << std::endl;
+        }
+        // We need the variables very soon. But don't configure them yet!
+        this->configuration_ = new CoreConfiguration();
+        // Parse command line arguments first
+        CommandLine::parseCommandLine(argc, argv);
+        // Determine and set the location of the executable
+        setExecutablePath();
+        // Determine whether we have an installed or a binary dir run
+        // The latter occurs when simply running from the build directory
+        checkDevBuild();
+        // Make sure the directories we write in exist or else make them
+        createDirectories();
+        // create a signal handler (only active for linux)
+        // This call is placed as soon as possible, but after the directories are set
+        this->signalHandler_ = new SignalHandler();
+        this->signalHandler_->doCatch(configuration_->executablePath_.string(), Core::getLogPathString() + "orxonox_crash.log");
+        // Set the correct log path. Before this call, /tmp (Unix) or %TEMP% was used
+        OutputHandler::getOutStream().setLogPath(Core::getLogPathString());
+        // Parse additional options file now that we know its path
+        CommandLine::parseFile();
+#ifdef ORXONOX_PLATFORM_WINDOWS
         // limit the main thread to the first core so that QueryPerformanceCounter doesn't jump
         // do this after ogre has initialised. Somehow Ogre changes the settings again (not through
 …
         int limitToCPU = CommandLine::getValue("limitToCPU");
         if (limitToCPU > 0)
+            setThreadAffinity((unsigned int)limitToCPU);
+        // Determine and set the location of the executable
+        setExecutablePath();
+        // Determine whether we have an installed or a binary dir run
+        // The latter occurs when simply running from the build directory
+        checkDevBuild();
+        // Make sure the directories we write in exist or else make them
+        createDirectories();
+        // create a signal handler (only active for linux)
+        // This call is placed as soon as possible, but after the directories are set
+        this->signalHandler_ = new SignalHandler();
+        this->signalHandler_->doCatch(executablePath_g.string(), Core::getLogPathString() + "orxonox_crash.log");
+        // Set the correct log path. Before this call, /tmp (Unix) or %TEMP% was used
+        OutputHandler::getOutStream().setLogPath(Core::getLogPathString());
+            setThreadAffinity(static_cast<unsigned int>(limitToCPU));
+#endif
         // Manage ini files and set the default settings file (usually orxonox.ini)
 …
             CommandLine::getValue("settingsFile").getString());
+        // Required as well for the config values
         this->languageInstance_ = new Language();
         // Do this soon after the ConfigFileManager has been created to open up the
         // possibility to configure everything below here
+        this->setConfigValues();
+        // Possible media path override by the command line
+        if (!CommandLine::getArgument("mediaPath")->hasDefaultValue())
+        {
+            //std::string mediaPath = CommandLine::getValue("mediaPath");
+            Core::tsetMediaPath(CommandLine::getValue("mediaPath"));
+        }
+        this->configuration_->initialise();
         // Create the lua interface
 …
         // creates the class hierarchy for all classes with factories
         Factory::createClassHierarchy();
-        this->loaded_ = true;
+    }
 …
     Core::~Core()
+    {
-        this->loaded_ = false;
         delete this->shell_;
         delete this->tclThreadManager_;
         delete this->tclBind_;
         delete this->luaBind_;
+        delete this->configuration_;
         delete this->languageInstance_;
         delete this->configFileManager_;
 …
         // Also delete external console command that don't belong to an Identifier
         CommandExecutor::destroyExternalCommands();
         assert(Core::singletonRef_s);
+        Core::singletonRef_s = 0;
+        // Clean up class hierarchy stuff (identifiers, XMLPort, configValues, consoleCommand)
+        Identifier::destroyAllIdentifiers();
         delete this->signalHandler_;
+    }
+    /**
+        @brief Function to collect the SetConfigValue-macro calls.
+    */
+    void Core::setConfigValues()
+    {
+#ifdef NDEBUG
+        const unsigned int defaultLevelConsole = 1;
+        const unsigned int defaultLevelLogfile = 3;
+        const unsigned int defaultLevelShell   = 1;
+#else
+        const unsigned int defaultLevelConsole = 3;
+        const unsigned int defaultLevelLogfile = 4;
+        const unsigned int defaultLevelShell   = 3;
+#endif
+        SetConfigValue(softDebugLevelConsole_, defaultLevelConsole)
+            .description("The maximal level of debug output shown in the console").callback(this, &Core::debugLevelChanged);
+        SetConfigValue(softDebugLevelLogfile_, defaultLevelLogfile)
+            .description("The maximal level of debug output shown in the logfile").callback(this, &Core::debugLevelChanged);
+        SetConfigValue(softDebugLevelShell_, defaultLevelShell)
+            .description("The maximal level of debug output shown in the ingame shell").callback(this, &Core::debugLevelChanged);
+        SetConfigValue(language_, Language::getLanguage().defaultLanguage_).description("The language of the ingame text").callback(this, &Core::languageChanged);
+        SetConfigValue(bInitializeRandomNumberGenerator_, true).description("If true, all random actions are different each time you start the game").callback(this, &Core::initializeRandomNumberGenerator);
+        SetConfigValue(mediaPathString_, mediaPath_g.string())
+            .description("Relative path to the game data.").callback(this, &Core::mediaPathChanged);
+    }
+    /**
+        @brief Callback function if the debug level has changed.
+    */
+    void Core::debugLevelChanged()
+    {
+        // softDebugLevel_ is the maximum of the 3 variables
+        this->softDebugLevel_ = this->softDebugLevelConsole_;
+        if (this->softDebugLevelLogfile_ > this->softDebugLevel_)
+            this->softDebugLevel_ = this->softDebugLevelLogfile_;
+        if (this->softDebugLevelShell_ > this->softDebugLevel_)
+            this->softDebugLevel_ = this->softDebugLevelShell_;
+        OutputHandler::setSoftDebugLevel(OutputHandler::LD_All,     this->softDebugLevel_);
+        OutputHandler::setSoftDebugLevel(OutputHandler::LD_Console, this->softDebugLevelConsole_);
+        OutputHandler::setSoftDebugLevel(OutputHandler::LD_Logfile, this->softDebugLevelLogfile_);
+        OutputHandler::setSoftDebugLevel(OutputHandler::LD_Shell,   this->softDebugLevelShell_);
+    }
+    /**
+        @brief Callback function if the language has changed.
+    */
+    void Core::languageChanged()
+    {
+        // Read the translation file after the language was configured
+        Language::getLanguage().readTranslatedLanguageFile();
+    }
+    /**
+    @brief
+        Callback function if the media path has changed.
+    */
+    void Core::mediaPathChanged()
+    {
+        mediaPath_g = boost::filesystem::path(this->mediaPathString_);
+    }
+    /**
+        @brief Returns the softDebugLevel for the given device (returns a default-value if the class ist right about to be created).
+        // Don't assign singletonRef_s with NULL! Recreation is not supported
+    }
+    /**
+        @brief Returns the softDebugLevel for the given device (returns a default-value if the class is right about to be created).
         @param device The device
         @return The softDebugLevel
     */
     int Core::getSoftDebugLevel(OutputHandler::OutputDevice device)
+    /*static*/ int Core::getSoftDebugLevel(OutputHandler::OutputDevice device)
+    {
         switch (device)
+        {
         case OutputHandler::LD_All:
             return Core::getInstance().softDebugLevel_;
+            return Core::getInstance().configuration_->softDebugLevel_;
         case OutputHandler::LD_Console:
             return Core::getInstance().softDebugLevelConsole_;
+            return Core::getInstance().configuration_->softDebugLevelConsole_;
         case OutputHandler::LD_Logfile:
             return Core::getInstance().softDebugLevelLogfile_;
+            return Core::getInstance().configuration_->softDebugLevelLogfile_;
         case OutputHandler::LD_Shell:
             return Core::getInstance().softDebugLevelShell_;
+            return Core::getInstance().configuration_->softDebugLevelShell_;
         default:
             assert(0);
 …
         @param level The level
     */
      void Core::setSoftDebugLevel(OutputHandler::OutputDevice device, int level)
+     {
+    /*static*/ void Core::setSoftDebugLevel(OutputHandler::OutputDevice device, int level)
+    {
         if (device == OutputHandler::LD_All)
             Core::getInstance().softDebugLevel_ = level;
+            Core::getInstance().configuration_->softDebugLevel_ = level;
         else if (device == OutputHandler::LD_Console)
             Core::getInstance().softDebugLevelConsole_ = level;
+            Core::getInstance().configuration_->softDebugLevelConsole_ = level;
         else if (device == OutputHandler::LD_Logfile)
             Core::getInstance().softDebugLevelLogfile_ = level;
+            Core::getInstance().configuration_->softDebugLevelLogfile_ = level;
         else if (device == OutputHandler::LD_Shell)
             Core::getInstance().softDebugLevelShell_ = level;
+            Core::getInstance().configuration_->softDebugLevelShell_ = level;
         OutputHandler::setSoftDebugLevel(device, level);
+     }
+    }
     /**
         @brief Returns the configured language.
     */
     const std::string& Core::getLanguage()
+    {
         return Core::getInstance().language_;
+    /*static*/ const std::string& Core::getLanguage()
+    {
+        return Core::getInstance().configuration_->language_;
+    }
 …
         @brief Sets the language in the config-file back to the default.
     */
+    void Core::resetLanguage()
+    {
+        Core::getInstance().resetLanguageIntern();
+    }
+    /**
+        @brief Sets the language in the config-file back to the default.
+    */
+    void Core::resetLanguageIntern()
+    {
+        ResetConfigValue(language_);
+    }
+    /**
+    @brief
+        Temporary sets the media path
+    @param path
+        The new media path
+    */
+    void Core::_tsetMediaPath(const std::string& path)
+    {
+        ModifyConfigValue(mediaPathString_, tset, path);
+    /*static*/ void Core::resetLanguage()
+    {
+        Core::getInstance().configuration_->resetLanguage();
+    }
+    /*static*/ void Core::tsetMediaPath(const std::string& path)
+    {
+        getInstance().configuration_->tsetMediaPath(path);
+    }
     /*static*/ const boost::filesystem::path& Core::getMediaPath()
+    {
         return mediaPath_g;
+        return getInstance().configuration_->mediaPath_;
+    }
     /*static*/ std::string Core::getMediaPathString()
+    {
         return mediaPath_g.string() + '/';
+        return getInstance().configuration_->mediaPath_.string() + '/';
+    }
     /*static*/ const boost::filesystem::path& Core::getConfigPath()
+    {
         return configPath_g;
+        return getInstance().configuration_->configPath_;
+    }
     /*static*/ std::string Core::getConfigPathString()
+    {
         return configPath_g.string() + '/';
+        return getInstance().configuration_->configPath_.string() + '/';
+    }
     /*static*/ const boost::filesystem::path& Core::getLogPath()
+    {
         return logPath_g;
+        return getInstance().configuration_->logPath_;
+    }
     /*static*/ std::string Core::getLogPathString()
+    {
+        return logPath_g.string() + '/';
+    }
+    void Core::initializeRandomNumberGenerator()
+    {
+        static bool bInitialized = false;
+        if (!bInitialized && this->bInitializeRandomNumberGenerator_)
+        {
+            srand(static_cast<unsigned int>(time(0)));
+            rand();
+            bInitialized = true;
+        }
+    }
+        return getInstance().configuration_->logPath_.string() + '/';
+    }
     /**
 …
     void Core::setThreadAffinity(int limitToCPU)
+    {
+#ifdef ORXONOX_PLATFORM_WINDOWS
         if (limitToCPU <= 0)
             return;
-#ifdef ORXONOX_PLATFORM_WINDOWS
         unsigned int coreNr = limitToCPU - 1;
         // Get the current process core mask
 …
 #endif
         executablePath_g = boost::filesystem::path(buffer);
+        configuration_->executablePath_ = boost::filesystem::path(buffer);
 #ifndef ORXONOX_PLATFORM_APPLE
         executablePath_g = executablePath_g.branch_path(); // remove executable name
+        configuration_->executablePath_ = configuration_->executablePath_.branch_path(); // remove executable name
 #endif
+    }
 …
     void Core::checkDevBuild()
+    {
         if (boost::filesystem::exists(executablePath_g / "orxonox_dev_build.keep_me"))
+        if (boost::filesystem::exists(configuration_->executablePath_ / "orxonox_dev_build.keep_me"))
+        {
             COUT(1) << "Running from the build tree." << std::endl;
             Core::isDevBuild_ = true;
             mediaPath_g  = ORXONOX_MEDIA_DEV_PATH;
             configPath_g = ORXONOX_CONFIG_DEV_PATH;
             logPath_g    = ORXONOX_LOG_DEV_PATH;
+            configuration_->mediaPath_  = ORXONOX_MEDIA_DEV_PATH;
+            configuration_->configPath_ = ORXONOX_CONFIG_DEV_PATH;
+            configuration_->logPath_    = ORXONOX_LOG_DEV_PATH;
+        }
         else
 …
             // Also set the root path
             boost::filesystem::path relativeExecutablePath(ORXONOX_RUNTIME_INSTALL_PATH);
+            rootPath_g = executablePath_g;
+            while (!boost::filesystem::equivalent(rootPath_g / relativeExecutablePath, executablePath_g) && !rootPath_g.empty())
+                rootPath_g = rootPath_g.branch_path();
+            if (rootPath_g.empty())
+            configuration_->rootPath_ = configuration_->executablePath_;
+            while (!boost::filesystem::equivalent(configuration_->rootPath_ / relativeExecutablePath, configuration_->executablePath_)
+                   && !configuration_->rootPath_.empty())
+                configuration_->rootPath_ = configuration_->rootPath_.branch_path();
+            if (configuration_->rootPath_.empty())
                 ThrowException(General, "Could not derive a root directory. Might the binary installation directory contain '..' when taken relative to the installation prefix path?");
             // Using paths relative to the install prefix, complete them
             mediaPath_g  = rootPath_g / ORXONOX_MEDIA_INSTALL_PATH;
             configPath_g = rootPath_g / ORXONOX_CONFIG_INSTALL_PATH;
             logPath_g    = rootPath_g / ORXONOX_LOG_INSTALL_PATH;
+            configuration_->mediaPath_  = configuration_->rootPath_ / ORXONOX_MEDIA_INSTALL_PATH;
+            configuration_->configPath_ = configuration_->rootPath_ / ORXONOX_CONFIG_INSTALL_PATH;
+            configuration_->logPath_    = configuration_->rootPath_ / ORXONOX_LOG_INSTALL_PATH;
 #else
             // There is no root path, so don't set it at all
             mediaPath_g  = ORXONOX_MEDIA_INSTALL_PATH;
+            configuration_->mediaPath_  = ORXONOX_MEDIA_INSTALL_PATH;
             // Get user directory
 …
             userDataPath /= ".orxonox";
             configPath_g = userDataPath / ORXONOX_CONFIG_INSTALL_PATH;
             logPath_g    = userDataPath / ORXONOX_LOG_INSTALL_PATH;
+            configuration_->configPath_ = userDataPath / ORXONOX_CONFIG_INSTALL_PATH;
+            configuration_->logPath_    = userDataPath / ORXONOX_LOG_INSTALL_PATH;
 #endif
+        }
 …
+        {
             std::string directory(CommandLine::getValue("writingPathSuffix").getString());
             configPath_g = configPath_g / directory;
             logPath_g    = logPath_g    / directory;
+            configuration_->configPath_ = configuration_->configPath_ / directory;
+            configuration_->logPath_    = configuration_->logPath_    / directory;
+        }
+    }
 …
+    {
         std::vector<std::pair<boost::filesystem::path, std::string> > directories;
         directories.push_back(std::make_pair(boost::filesystem::path(configPath_g), "config"));
         directories.push_back(std::make_pair(boost::filesystem::path(logPath_g), "log"));
+        directories.push_back(std::make_pair(boost::filesystem::path(configuration_->configPath_), "config"));
+        directories.push_back(std::make_pair(boost::filesystem::path(configuration_->logPath_), "log"));
         for (std::vector<std::pair<boost::filesystem::path, std::string> >::iterator it = directories.begin();

code/trunk/src/core/Core.h

-                      r3196
+                      r3280
 #include <cassert>
-#include "OrxonoxClass.h"
 #include "util/OutputHandler.h"
 namespace orxonox
+{
+    class CoreConfiguration;
     /**
     @brief
 …
         It determines those by the use of platform specific functions.
     */
     class _CoreExport Core : public OrxonoxClass
+    class _CoreExport Core
+    {
         public:
 …
                 GeneralException
             */
             Core();
+            Core(int argc, char** argv);
             ~Core();
-            void initialise(int argc, char** argv);
             void setConfigValues();
 …
             static void  resetLanguage();
+            static void tsetMediaPath(const std::string& path)
+            { assert(singletonRef_s); singletonRef_s->_tsetMediaPath(path); }
+            static void tsetMediaPath(const std::string& path);
             //! Returns the path to the config files as boost::filesystem::path
             static const boost::filesystem::path& getMediaPath();
 …
             void setThreadAffinity(int limitToCPU);
-            void resetLanguageIntern();
-            void initializeRandomNumberGenerator();
-            void debugLevelChanged();
-            void languageChanged();
-            void mediaPathChanged();
-            void _tsetMediaPath(const std::string& path);
             // Singletons
             ConfigFileManager*    configFileManager_;
 …
             TclThreadManager*     tclThreadManager_;
-            int softDebugLevel_;                            //!< The debug level
-            int softDebugLevelConsole_;                     //!< The debug level for the console
-            int softDebugLevelLogfile_;                     //!< The debug level for the logfile
-            int softDebugLevelShell_;                       //!< The debug level for the ingame shell
-            std::string language_;                          //!< The language
-            bool bInitializeRandomNumberGenerator_;         //!< If true, srand(time(0)) is called
-            std::string mediaPathString_;                   //!< Path to the data/media file folder as string
             bool isDevBuild_;                               //!< True for builds in the build directory (not installed)
             bool loaded_;                                   //!< Only true if constructor was interrupted
+            CoreConfiguration*    configuration_;
             static Core* singletonRef_s;

code/trunk/src/core/CorePrereqs.h

-                      r3196
+                      r3280
     namespace KeybindMode
+    {
         enum Enum
+        enum Value
+        {
             OnPress,
 …
     // game states
     class Game;
+    struct GameStateConstrParams;
     class GameState;
     struct GameStateTreeNode;

code/trunk/src/core/Executor.cc

-                      r3196
+                      r3280
             // assign all given arguments to the multitypes
             for (unsigned int i = 0; i < min(tokens.size(), (unsigned int)MAX_FUNCTOR_ARGUMENTS); i++)
+            for (unsigned int i = 0; i < std::min(tokens.size(), (unsigned int)MAX_FUNCTOR_ARGUMENTS); i++)
                 param[i] = tokens[i];
             // fill the remaining multitypes with default values
             for (unsigned int i = tokens.size(); i < min(paramCount, (unsigned int)MAX_FUNCTOR_ARGUMENTS); i++)
+            for (unsigned int i = tokens.size(); i < std::min(paramCount, (unsigned int)MAX_FUNCTOR_ARGUMENTS); i++)
                 param[i] = this->defaultValue_[i];
             // evaluate the param types through the functor
             for (unsigned int i = 0; i < min(paramCount, (unsigned int)MAX_FUNCTOR_ARGUMENTS); i++)
+            for (unsigned int i = 0; i < std::min(paramCount, (unsigned int)MAX_FUNCTOR_ARGUMENTS); i++)
                 this->functor_->evaluateParam(i, param[i]);

code/trunk/src/core/Executor.h

-                      r3196
+                      r3280
 #include "CorePrereqs.h"
+#include <algorithm>
+#include <string>
 #include "util/Debug.h"
 #include "util/Math.h"
 #include "util/String.h"
+#include "util/StringUtils.h"
 #include "util/SubString.h"
 #include "Functor.h"
 …
             COUT(5) << tokens[i]; \
         } \
         COUT(5) << ") and " << max((int)paramCount - (int)tokens.size(), 0) << " default values ("; \
+        COUT(5) << ") and " << std::max((int)paramCount - (int)tokens.size(), 0) << " default values ("; \
         for (unsigned int i = tokens.size(); i < paramCount; i++) \
         { \
 …
             inline bool hasReturnvalue() const
                 { return this->functor_->hasReturnvalue(); }
             inline FunctionType getType() const
+            inline FunctionType::Value getType() const
                 { return this->functor_->getType(); }
             inline const MultiType& getReturnvalue() const
 …
                     return this->defaultValue_[index];
                 return MT_null;
+                return MT_Type::Null;
+            }

code/trunk/src/core/Functor.h

-                      r3196
+                      r3280
 #include "util/Debug.h"
 #include "util/MultiType.h"
 #include "util/String.h"
+#include "util/StringUtils.h"
 namespace orxonox
 …
     const unsigned int MAX_FUNCTOR_ARGUMENTS = 5;
     enum FunctionType
+    namespace FunctionType
+    {
+        FT_MEMBER,
+        FT_CONSTMEMBER,
+        FT_STATIC
+    };
+        enum Value
+        {
+            Member,
+            ConstMember,
+            Static
+        };
+    }
 …
             virtual ~Functor() {}
             virtual void operator()(const MultiType& param1 = MT_null, const MultiType& param2 = MT_null, const MultiType& param3 = MT_null, const MultiType& param4 = MT_null, const MultiType& param5 = MT_null) = 0;
+            virtual void operator()(const MultiType& param1 = MT_Type::Null, const MultiType& param2 = MT_Type::Null, const MultiType& param3 = MT_Type::Null, const MultiType& param4 = MT_Type::Null, const MultiType& param5 = MT_Type::Null) = 0;
             inline unsigned int getParamCount() const { return this->numParams_; }
             inline bool hasReturnvalue() const { return this->hasReturnValue_; }
             inline FunctionType getType() const { return this->type_; }
+            inline FunctionType::Value getType() const { return this->type_; }
             inline const MultiType& getReturnvalue() const { return this->returnedValue_; }
 …
             unsigned int numParams_;
             bool hasReturnValue_;
             FunctionType type_;
+            FunctionType::Value type_;
             MultiType returnedValue_;
 …
         public:
             virtual ~FunctorStatic() {}
             virtual void operator()(const MultiType& param1 = MT_null, const MultiType& param2 = MT_null, const MultiType& param3 = MT_null, const MultiType& param4 = MT_null, const MultiType& param5 = MT_null) = 0;
+            virtual void operator()(const MultiType& param1 = MT_Type::Null, const MultiType& param2 = MT_Type::Null, const MultiType& param3 = MT_Type::Null, const MultiType& param4 = MT_Type::Null, const MultiType& param5 = MT_Type::Null) = 0;
     };
 …
             virtual ~FunctorMember() {}
             virtual void operator()(T* object, const MultiType& param1 = MT_null, const MultiType& param2 = MT_null, const MultiType& param3 = MT_null, const MultiType& param4 = MT_null, const MultiType& param5 = MT_null) = 0;
             virtual void operator()(const T* object, const MultiType& param1 = MT_null, const MultiType& param2 = MT_null, const MultiType& param3 = MT_null, const MultiType& param4 = MT_null, const MultiType& param5 = MT_null) = 0;
             virtual void operator()(const MultiType& param1 = MT_null, const MultiType& param2 = MT_null, const MultiType& param3 = MT_null, const MultiType& param4 = MT_null, const MultiType& param5 = MT_null)
+            virtual void operator()(T* object, const MultiType& param1 = MT_Type::Null, const MultiType& param2 = MT_Type::Null, const MultiType& param3 = MT_Type::Null, const MultiType& param4 = MT_Type::Null, const MultiType& param5 = MT_Type::Null) = 0;
+            virtual void operator()(const T* object, const MultiType& param1 = MT_Type::Null, const MultiType& param2 = MT_Type::Null, const MultiType& param3 = MT_Type::Null, const MultiType& param4 = MT_Type::Null, const MultiType& param5 = MT_Type::Null) = 0;
+            virtual void operator()(const MultiType& param1 = MT_Type::Null, const MultiType& param2 = MT_Type::Null, const MultiType& param3 = MT_Type::Null, const MultiType& param4 = MT_Type::Null, const MultiType& param5 = MT_Type::Null)
+            {
                 if (this->bConstObject_)
 …
                 this->numParams_ = numparams; \
                 this->hasReturnValue_ = returnvalue; \
                 this->type_ = FT_STATIC; \
+                this->type_ = FunctionType::Static; \
                 this->functionPointer_ = functionPointer; \
+                \
 …
             } \
+    \
             void operator()(const MultiType& param1 = MT_null, const MultiType& param2 = MT_null, const MultiType& param3 = MT_null, const MultiType& param4 = MT_null, const MultiType& param5 = MT_null) \
+            void operator()(const MultiType& param1 = MT_Type::Null, const MultiType& param2 = MT_Type::Null, const MultiType& param3 = MT_Type::Null, const MultiType& param4 = MT_Type::Null, const MultiType& param5 = MT_Type::Null) \
             { \
                 FUNCTOR_STORE_RETURNVALUE(returnvalue, (*this->functionPointer_)(FUNCTOR_FUNCTION_CALL(numparams))); \
 …
                 this->numParams_ = numparams; \
                 this->hasReturnValue_ = returnvalue; \
                 this->type_ = FT_MEMBER; \
+                this->type_ = FunctionType::Member; \
                 this->functionPointer_ = functionPointer; \
             } \
+    \
             void operator()(T* object, const MultiType& param1 = MT_null, const MultiType& param2 = MT_null, const MultiType& param3 = MT_null, const MultiType& param4 = MT_null, const MultiType& param5 = MT_null) \
+            void operator()(T* object, const MultiType& param1 = MT_Type::Null, const MultiType& param2 = MT_Type::Null, const MultiType& param3 = MT_Type::Null, const MultiType& param4 = MT_Type::Null, const MultiType& param5 = MT_Type::Null) \
             { \
                 FUNCTOR_STORE_RETURNVALUE(returnvalue, (*object.*this->functionPointer_)(FUNCTOR_FUNCTION_CALL(numparams))); \
             } \
+    \
             void operator()(const T* object, const MultiType& param1 = MT_null, const MultiType& param2 = MT_null, const MultiType& param3 = MT_null, const MultiType& param4 = MT_null, const MultiType& param5 = MT_null) \
+            void operator()(const T* object, const MultiType& param1 = MT_Type::Null, const MultiType& param2 = MT_Type::Null, const MultiType& param3 = MT_Type::Null, const MultiType& param4 = MT_Type::Null, const MultiType& param5 = MT_Type::Null) \
             { \
                 COUT(1) << "An error occurred in Functor.h:" << std::endl; \
 …
                 this->numParams_ = numparams; \
                 this->hasReturnValue_ = returnvalue; \
                 this->type_ = FT_CONSTMEMBER; \
+                this->type_ = FunctionType::ConstMember; \
                 this->functionPointer_ = functionPointer; \
             } \
+    \
             void operator()(T* object, const MultiType& param1 = MT_null, const MultiType& param2 = MT_null, const MultiType& param3 = MT_null, const MultiType& param4 = MT_null, const MultiType& param5 = MT_null) \
+            void operator()(T* object, const MultiType& param1 = MT_Type::Null, const MultiType& param2 = MT_Type::Null, const MultiType& param3 = MT_Type::Null, const MultiType& param4 = MT_Type::Null, const MultiType& param5 = MT_Type::Null) \
             { \
                 FUNCTOR_STORE_RETURNVALUE(returnvalue, (*object.*this->functionPointer_)(FUNCTOR_FUNCTION_CALL(numparams))); \
             } \
+    \
             void operator()(const T* object, const MultiType& param1 = MT_null, const MultiType& param2 = MT_null, const MultiType& param3 = MT_null, const MultiType& param4 = MT_null, const MultiType& param5 = MT_null) \
+            void operator()(const T* object, const MultiType& param1 = MT_Type::Null, const MultiType& param2 = MT_Type::Null, const MultiType& param3 = MT_Type::Null, const MultiType& param4 = MT_Type::Null, const MultiType& param5 = MT_Type::Null) \
             { \
                 FUNCTOR_STORE_RETURNVALUE(returnvalue, (*object.*this->functionPointer_)(FUNCTOR_FUNCTION_CALL(numparams))); \

code/trunk/src/core/Game.cc

-                      r3196
+                      r3280
     SetConsoleCommandShortcutExternAlias(stop_game, "exit");
+    struct _CoreExport GameStateTreeNode
+    std::map<std::string, Game::GameStateInfo> Game::gameStateDeclarations_s;
+    Game* Game::singletonRef_s = 0;
+    /**
+    @brief
+        Represents one node of the game state tree.
+    */
+    struct GameStateTreeNode
+    {
         GameState* state_;
 …
     };
+    std::map<std::string, GameState*> Game::allStates_s;
+    Game* Game::singletonRef_s = 0;
+    /**
+    @brief
+        Another helper class for the Game singleton: we cannot derive
+        Game from OrxonoxClass because we need to handle the Identifier
+        destruction in the Core destructor.
+    */
+    class GameConfiguration : public OrxonoxClass
+    {
+    public:
+        GameConfiguration()
+        {
+            RegisterRootObject(GameConfiguration);
+            this->setConfigValues();
+        }
+        void setConfigValues()
+        {
+            SetConfigValue(statisticsRefreshCycle_, 250000)
+                .description("Sets the time in microseconds interval at which average fps, etc. get updated.");
+            SetConfigValue(statisticsAvgLength_, 1000000)
+                .description("Sets the time in microseconds interval at which average fps, etc. gets calculated.");
+        }
+        unsigned int statisticsRefreshCycle_;
+        unsigned int statisticsAvgLength_;
+    };
     /**
 …
     Game::Game(int argc, char** argv)
+    {
+        assert(singletonRef_s == 0);
+        if (singletonRef_s != 0)
+        {
+            COUT(0) << "Error: The Game singleton cannot be recreated! Shutting down." << std::endl;
+            abort();
+        }
         singletonRef_s = this;
+        this->abort_ = false;
+        this->bAbort_ = false;
+        bChangingState_ = false;
+        // Create an empty root state
+        declareGameState<GameState>("GameState", "emptyRootGameState", true, false);
         // reset statistics
 …
         this->avgTickTime_ = 0.0f;
         // Set up a basic clock to keep time
         this->gameClock_ = new Clock();
+        this->core_ = new orxonox::Core();
+        this->core_->initialise(argc, argv);
+        RegisterRootObject(Game);
+        this->setConfigValues();
+        // Create the Core
+        this->core_ = new Core(argc, argv);
+        // After the core has been created, we can safely instantiate the GameStates
+        for (std::map<std::string, GameStateInfo>::const_iterator it = gameStateDeclarations_s.begin();
+            it != gameStateDeclarations_s.end(); ++it)
+        {
+            // Only create the states appropriate for the game mode
+            //if (GameMode::showsGraphics || !it->second.bGraphicsMode)
+            GameStateConstrParams params = { it->second.stateName, it->second.bIgnoreTickTime };
+            gameStates_[getLowercase(it->second.stateName)] = GameStateFactory::fabricate(it->second.className, params);
+        }
+        // The empty root state is ALWAYS loaded!
+        this->rootStateNode_ = shared_ptr<GameStateTreeNode>(new GameStateTreeNode());
+        this->rootStateNode_->state_ = getState("emptyRootGameState");
+        this->activeStateNode_ = this->rootStateNode_;
+        this->activeStates_.push_back(this->rootStateNode_->state_);
+        // Do this after the Core creation!
+        this->configuration_ = new GameConfiguration();
+    }
 …
     Game::~Game()
+    {
+        // Destroy pretty much everyhting left
+        // Destroy the configuration helper class instance
+        delete this->configuration_;
+        // Destroy the GameStates (note that the nodes still point to them, but doesn't matter)
+        for (std::map<std::string, GameState*>::const_iterator it = gameStates_.begin();
+            it != gameStates_.end(); ++it)
+            delete it->second;
+        // Destroy the Core and with it almost everything
         delete this->core_;
         delete this->gameClock_;
+        assert(singletonRef_s);
+        singletonRef_s = 0;
+    }
+    void Game::setConfigValues()
+    {
+        SetConfigValue(statisticsRefreshCycle_, 250000)
+            .description("Sets the time in microseconds interval at which average fps, etc. get updated.");
+        SetConfigValue(statisticsAvgLength_, 1000000)
+            .description("Sets the time in microseconds interval at which average fps, etc. gets calculated.");
+        SetConfigValue(levelName_, "presentation_dm.oxw")
+            .description("Sets the preselection of the level in the main menu.");
+    }
+    void Game::setLevel(std::string levelName)
+    {
+        ModifyConfigValue(levelName_, set, levelName);
+    }
+    std::string Game::getLevel()
+    {
+        std::string levelName;
+        CommandLine::getValue("level", &levelName);
+        if (levelName == "")
+            return levelName_;
+        else
+            return levelName;
+        // Take care of the GameStateFactories
+        GameStateFactory::destroyFactories();
+        // Don't assign singletonRef_s with NULL! Recreation is not supported
+    }
 …
     void Game::run()
+    {
+        // Always start with the ROOT state
+        this->requestedStateNodes_.push_back(this->rootStateNode_);
+        this->activeStateNode_ = this->rootStateNode_;
+        this->loadState(this->rootStateNode_->state_);
+        if (this->requestedStateNodes_.empty())
+            COUT(0) << "Warning: Starting game without requesting GameState. This automatically terminates the program." << std::endl;
         // START GAME
         this->gameClock_->capture(); // first delta time should be about 0 seconds
         while (!this->abort_ && !this->activeStates_.empty())
+        while (!this->bAbort_ && (!this->activeStates_.empty() || this->requestedStateNodes_.size() > 0))
+        {
             this->gameClock_->capture();
 …
             // STATISTICS
             statisticsTickInfo tickInfo = {currentTime, 0};
+            StatisticsTickInfo tickInfo = {currentTime, 0};
             statisticsTickTimes_.push_back(tickInfo);
             this->periodTime_ += this->gameClock_->getDeltaTimeMicroseconds();
             // UPDATE STATE STACK
             while (this->requestedStateNodes_.size() > 1)
+            {
                 // Note: this->requestedStateNodes_.front() is the currently active state node
                 std::vector<shared_ptr<GameStateTreeNode> >::iterator it = this->requestedStateNodes_.begin() + 1;
                 if (*it == this->activeStateNode_->parent_.lock())
+            while (this->requestedStateNodes_.size() > 0)
+            {
+                shared_ptr<GameStateTreeNode> requestedStateNode = this->requestedStateNodes_.front();
+                assert(this->activeStateNode_);
+                if (!this->activeStateNode_->parent_.expired() && requestedStateNode == this->activeStateNode_->parent_.lock())
                     this->unloadState(this->activeStateNode_->state_);
                 else // has to be child
+                    this->loadState((*it)->state_);
+                this->activeStateNode_ = *it;
+                {
+                    try
+                    {
+                        this->loadState(requestedStateNode->state_);
+                    }
+                    catch (const std::exception& ex)
+                    {
+                        COUT(1) << "Error: Loading GameState '" << requestedStateNode->state_->getName() << "' failed: " << ex.what() << std::endl;
+                        // All scheduled operations have now been rendered inert --> flush them and issue a warning
+                        if (this->requestedStateNodes_.size() > 1)
+                            COUT(1) << "All " << this->requestedStateNodes_.size() - 1 << " scheduled transitions have been ignored." << std::endl;
+                        this->requestedStateNodes_.clear();
+                        break;
+                    }
+                }
+                this->activeStateNode_ = requestedStateNode;
                 this->requestedStateNodes_.erase(this->requestedStateNodes_.begin());
+            }
+            // UPDATE, bottom to top in the stack
+            this->core_->update(*this->gameClock_);
+            for (std::vector<GameState*>::const_iterator it = this->activeStates_.begin();
+            // UPDATE, Core first
+            try
+            {
+                this->core_->update(*this->gameClock_);
+            }
+            catch (...)
+            {
+                COUT(0) << "An exception occured while ticking the Core. This should really never happen!" << std::endl;
+                COUT(0) << "Closing the program." << std::endl;
+                this->stop();
+                break;
+            }
+            // UPDATE, GameStates bottom to top in the stack
+            // Note: The first element is the empty root state, which doesn't need ticking
+            for (std::vector<GameState*>::const_iterator it = this->activeStates_.begin() + 1;
                 it != this->activeStates_.end(); ++it)
+            {
+                // Add tick time for most of the states
+                uint64_t timeBeforeTick;
+                if ((*it)->getCountTickTime())
+                    timeBeforeTick = this->gameClock_->getRealMicroseconds();
+                (*it)->update(*this->gameClock_);
+                if ((*it)->getCountTickTime())
+                    this->addTickTime(static_cast<uint32_t>(this->gameClock_->getRealMicroseconds() - timeBeforeTick));
+                bool threwException = false;
+                try
+                {
+                    // Add tick time for most of the states
+                    uint64_t timeBeforeTick;
+                    if (!(*it)->ignoreTickTime())
+                        timeBeforeTick = this->gameClock_->getRealMicroseconds();
+                    (*it)->update(*this->gameClock_);
+                    if (!(*it)->ignoreTickTime())
+                        this->addTickTime(static_cast<uint32_t>(this->gameClock_->getRealMicroseconds() - timeBeforeTick));
+                }
+                catch (const std::exception& ex)
+                {
+                    threwException = true;
+                    COUT(0) << "Exception while ticking: " << ex.what() << std::endl;
+                }
+                catch (...)
+                {
+                    threwException = true;
+                }
+                if (threwException)
+                {
+                    COUT(1) << "An exception occured while ticking GameState '" << (*it)->getName() << "'. This should really never happen!" << std::endl;
+                    COUT(1) << "Unloading all GameStates depending on the one that crashed." << std::endl;
+                    if ((*it)->getParent() != NULL)
+                        this->requestState((*it)->getParent()->getName());
+                    else
+                        this->stop();
+                    break;
+                }
+            }
             // STATISTICS
             if (this->periodTime_ > statisticsRefreshCycle_)
+            {
                 std::list<statisticsTickInfo>::iterator it = this->statisticsTickTimes_.begin();
+            if (this->periodTime_ > this->configuration_->statisticsRefreshCycle_)
+            {
+                std::list<StatisticsTickInfo>::iterator it = this->statisticsTickTimes_.begin();
                 assert(it != this->statisticsTickTimes_.end());
                 int64_t lastTime = currentTime - this->statisticsAvgLength_;
+                int64_t lastTime = currentTime - this->configuration_->statisticsAvgLength_;
                 if ((int64_t)it->tickTime < lastTime)
+                {
                     do
+                    {
                         assert(this->periodTickTime_ > it->tickLength);
+                        assert(this->periodTickTime_ >= it->tickLength);
                         this->periodTickTime_ -= it->tickLength;
                         ++it;
 …
                 this->avgTickTime_ = static_cast<float>(this->periodTickTime_) / framesPerPeriod / 1000.0f;
                 this->periodTime_ -= this->statisticsRefreshCycle_;
+                this->periodTime_ -= this->configuration_->statisticsRefreshCycle_;
+            }
+        }
         // UNLOAD all remaining states
         while (!this->activeStates_.empty())
+        while (this->activeStates_.size() > 1)
             this->unloadState(this->activeStates_.back());
         this->activeStateNode_.reset();
+        this->activeStateNode_ = this->rootStateNode_;
         this->requestedStateNodes_.clear();
+    }
 …
     void Game::stop()
+    {
         this->abort_ = true;
+        this->bAbort_ = true;
+    }
 …
+    {
         GameState* state = this->getState(name);
         if (state == NULL || this->activeStateNode_ == NULL)
+        if (state == NULL)
             return;
+        shared_ptr<GameStateTreeNode> requestedNode;
+        // this->requestedStateNodes_.back() is the currently active state
+        shared_ptr<GameStateTreeNode> lastRequestedNode = this->requestedStateNodes_.back();
+        // Already the active node?
+        //if (this->bChangingState_)
+        //{
+        //    COUT(2) << "Warning: Requesting GameStates while loading/unloading a GameState is illegal! Ignoring." << std::endl;
+        //    return;
+        //}
+        shared_ptr<GameStateTreeNode> lastRequestedNode;
+        if (this->requestedStateNodes_.empty())
+            lastRequestedNode = this->activeStateNode_;
+        else
+            lastRequestedNode = this->requestedStateNodes_.back();
         if (state == lastRequestedNode->state_)
+        {
 …
         // Check children first
+        std::vector<shared_ptr<GameStateTreeNode> > requestedNodes;
         for (unsigned int i = 0; i < lastRequestedNode->children_.size(); ++i)
+        {
             if (lastRequestedNode->children_[i]->state_ == state)
+            {
                 requestedNode = lastRequestedNode->children_[i];
+                requestedNodes.push_back(lastRequestedNode->children_[i]);
                 break;
+            }
+        }
+        // Check parent and all its grand parents
+        shared_ptr<GameStateTreeNode> currentNode = lastRequestedNode;
+        while (requestedNode == NULL && currentNode != NULL)
+        {
+            if (currentNode->state_ == state)
+                requestedNode = currentNode;
+            currentNode = currentNode->parent_.lock();
+        }
+        if (requestedNode == NULL)
+        if (requestedNodes.empty())
+        {
+            // Check parent and all its grand parents
+            shared_ptr<GameStateTreeNode> currentNode = lastRequestedNode;
+            while (currentNode != NULL)
+            {
+                if (currentNode->state_ == state)
+                    break;
+                currentNode = currentNode->parent_.lock();
+                requestedNodes.push_back(currentNode);
+            }
+        }
+        if (requestedNodes.empty())
             COUT(1) << "Error: Requested GameState transition is not allowed. Ignoring." << std::endl;
         else
             this->requestedStateNodes_.push_back(requestedNode);
+            this->requestedStateNodes_.insert(requestedStateNodes_.end(), requestedNodes.begin(), requestedNodes.end());
+    }
 …
     void Game::popState()
+    {
+        if (this->activeStateNode_ != NULL && this->requestedStateNodes_.back()->parent_.lock())
+            this->requestState(this->requestedStateNodes_.back()->parent_.lock()->state_->getName());
+        shared_ptr<GameStateTreeNode> lastRequestedNode;
+        if (this->requestedStateNodes_.empty())
+            lastRequestedNode = this->activeStateNode_;
         else
+            COUT(2) << "Warning: Could not pop GameState. Ignoring." << std::endl;
+            lastRequestedNode = this->requestedStateNodes_.back();
+        if (lastRequestedNode != this->rootStateNode_)
+            this->requestState(lastRequestedNode->parent_.lock()->state_->getName());
+        else
+            COUT(2) << "Warning: Can't pop the internal dummy root GameState" << std::endl;
+    }
     GameState* Game::getState(const std::string& name)
+    {
         std::map<std::string, GameState*>::const_iterator it = allStates_s.find(getLowercase(name));
         if (it != allStates_s.end())
+        std::map<std::string, GameState*>::const_iterator it = gameStates_.find(getLowercase(name));
+        if (it != gameStates_.end())
             return it->second;
         else
 …
             while(pos < str.size() && str[pos] != ' ')
                 ++pos;
+            stateStrings.push_back(std::pair<std::string, unsigned>(
+                str.substr(startPos, pos - startPos), indentation));
+            stateStrings.push_back(std::make_pair(str.substr(startPos, pos - startPos), indentation));
+        }
         unsigned int currentLevel = 0;
         shared_ptr<GameStateTreeNode> currentNode;
+        shared_ptr<GameStateTreeNode> currentNode = this->rootStateNode_;
         for (std::vector<std::pair<std::string, unsigned> >::const_iterator it = stateStrings.begin(); it != stateStrings.end(); ++it)
+        {
             std::string newStateName = it->first;
             unsigned newLevel = it->second;
+            unsigned newLevel = it->second + 1; // empty root is 0
             GameState* newState = this->getState(newStateName);
             if (!newState)
+                ThrowException(GameState, std::string("GameState with name '") + newStateName + "' not found!");
+            if (newLevel == 0)
+            {
+                // root
+                if (this->rootStateNode_ != NULL)
+                    ThrowException(GameState, "No two root GameStates are allowed!");
+                shared_ptr<GameStateTreeNode> newNode(new GameStateTreeNode);
+                newNode->state_ = newState;
+                this->rootStateNode_ = newNode;
+                currentNode = this->rootStateNode_;
+            }
+            else if (currentNode)
+            {
+                shared_ptr<GameStateTreeNode> newNode(new GameStateTreeNode);
+                newNode->state_ = newState;
+                if (newLevel < currentLevel)
+                {
+                    // Get down the hierarchy
+                    do
+                        currentNode = currentNode->parent_.lock();
+                    while (newLevel < --currentLevel);
+                }
+                if (newLevel == currentLevel)
+                {
+                    // same level
+                    newNode->parent_ = currentNode->parent_;
+                    newNode->parent_.lock()->children_.push_back(newNode);
+                }
+                else if (newLevel == currentLevel + 1)
+                {
+                    // child
+                    newNode->parent_ = currentNode;
+                    currentNode->children_.push_back(newNode);
+                }
+                else
+                    ThrowException(GameState, "Indentation error while parsing the hierarchy.");
+                currentNode = newNode;
+                currentLevel = newLevel;
+                ThrowException(GameState, "GameState with name '" << newStateName << "' not found!");
+            if (newState == this->rootStateNode_->state_)
+                ThrowException(GameState, "You shouldn't use 'emptyRootGameState' in the hierarchy...");
+            shared_ptr<GameStateTreeNode> newNode(new GameStateTreeNode);
+            newNode->state_ = newState;
+            if (newLevel <= currentLevel)
+            {
+                do
+                    currentNode = currentNode->parent_.lock();
+                while (newLevel <= --currentLevel);
+            }
+            if (newLevel == currentLevel + 1)
+            {
+                // Add the child
+                newNode->parent_ = currentNode;
+                currentNode->children_.push_back(newNode);
+                currentNode->state_->addChild(newNode->state_);
+            }
             else
+            {
                 ThrowException(GameState, "No root GameState specified!");
+            }
+                ThrowException(GameState, "Indentation error while parsing the hierarchy.");
+            currentNode = newNode;
+            currentLevel = newLevel;
+        }
+    }
 …
     void Game::loadState(GameState* state)
+    {
+        this->bChangingState_ = true;
+        state->activate();
         if (!this->activeStates_.empty())
             this->activeStates_.back()->activity_.topState = false;
         state->activate();
+        this->activeStates_.push_back(state);
         state->activity_.topState = true;
         this->activeStates_.push_back(state);
+        this->bChangingState_ = false;
+    }
     void Game::unloadState(orxonox::GameState* state)
+    {
+        this->bChangingState_ = true;
         state->activity_.topState = false;
-        state->deactivate();
         this->activeStates_.pop_back();
         if (!this->activeStates_.empty())
             this->activeStates_.back()->activity_.topState = true;
+    }
+    /*static*/ bool Game::addGameState(GameState* state)
+    {
+        std::map<std::string, GameState*>::const_iterator it = allStates_s.find(getLowercase(state->getName()));
+        if (it == allStates_s.end())
+            allStates_s[getLowercase(state->getName())] = state;
+        else
+            ThrowException(GameState, "Cannot add two GameStates with the same name to 'Game'.");
+        // just a required dummy return value
+        return true;
+    }
+    /*static*/ void Game::destroyStates()
+    {
+        // Delete all GameStates created by the macros
+        for (std::map<std::string, GameState*>::const_iterator it = allStates_s.begin(); it != allStates_s.end(); ++it)
+        try
+        {
+            state->deactivate();
+        }
+        catch (const std::exception& ex)
+        {
+            COUT(2) << "Warning: Unloading GameState '" << state->getName() << "' threw an exception: " << ex.what() << std::endl;
+            COUT(2) << "         There might be potential resource leaks involved! To avoid this, improve exception-safety." << std::endl;
+        }
+        this->bChangingState_ = false;
+    }
+    std::map<std::string, Game::GameStateFactory*> Game::GameStateFactory::factories_s;
+    /*static*/ GameState* Game::GameStateFactory::fabricate(const std::string& className, const GameStateConstrParams& params)
+    {
+        std::map<std::string, GameStateFactory*>::const_iterator it = factories_s.find(className);
+        assert(it != factories_s.end());
+        return it->second->fabricate(params);
+    }
+    /*static*/ void Game::GameStateFactory::destroyFactories()
+    {
+        for (std::map<std::string, GameStateFactory*>::const_iterator it = factories_s.begin(); it != factories_s.end(); ++it)
             delete it->second;
         allStates_s.clear();
+        factories_s.clear();
+    }
+}

code/trunk/src/core/Game.h

-                      r3196
+                      r3280
 #include <boost/preprocessor/cat.hpp>
+#include "OrxonoxClass.h"
+#include "util/Debug.h"
+#include "util/StringUtils.h"
 /**
 …
     and every following paramter is a constructor argument (which is usually non existent)
 */
 #define AddGameState(classname, ...) \
     static bool BOOST_PP_CAT(bGameStateDummy_##classname, __LINE__) = orxonox::Game::addGameState(new classname(__VA_ARGS__))
+#define DeclareGameState(className, stateName, bIgnoreTickTime, bGraphicsMode) \
+    static bool BOOST_PP_CAT(bGameStateDummy_##className, __LINE__) = orxonox::Game::declareGameState<className>(#className, stateName, bIgnoreTickTime, bGraphicsMode)
-// tolua_begin
 namespace orxonox
+{
+    class GameConfiguration;
     /**
     @brief
 …
     */
     class _CoreExport Game
-    // tolua_end
-        : public OrxonoxClass
-    // tolua_begin
+    {
-    //tolua_end
     public:
         Game(int argc, char** argv);
         ~Game();
-        void setConfigValues();
         void setStateHierarchy(const std::string& str);
 …
         void addTickTime(uint32_t length);
+        static bool addGameState(GameState* state);
+        static void destroyStates();
+        static Game& getInstance() { assert(singletonRef_s); return *singletonRef_s; } //tolua_export
+        void setLevel(std::string levelName); //tolua_export
+        std::string getLevel(); //tolua_export
+        template <class T>
+        static bool declareGameState(const std::string& className, const std::string& stateName, bool bIgnoreTickTime, bool bConsoleMode);
+        static Game& getInstance() { assert(singletonRef_s); return *singletonRef_s; }
     private:
+        struct statisticsTickInfo
+        class _CoreExport GameStateFactory
+        {
+        public:
+            virtual ~GameStateFactory() { }
+            static GameState* fabricate(const std::string& className, const GameStateConstrParams& params);
+            template <class T>
+            static void createFactory(const std::string& className)
+                { factories_s[className] = new TemplateGameStateFactory<T>(); }
+            static void destroyFactories();
+        private:
+            virtual GameState* fabricate(const GameStateConstrParams& params) = 0;
+            static std::map<std::string, GameStateFactory*> factories_s;
+        };
+        template <class T>
+        class TemplateGameStateFactory : public GameStateFactory
+        {
+        public:
+            GameState* fabricate(const GameStateConstrParams& params)
+                { return new T(params); }
+        };
+        struct GameStateInfo
+        {
+            std::string stateName;
+            std::string className;
+            bool bIgnoreTickTime;
+            bool bGraphicsMode;
+        };
+        struct StatisticsTickInfo
+        {
             uint64_t    tickTime;
 …
         void unloadState(GameState* state);
+        std::vector<GameState*>         activeStates_;
+        std::map<std::string, GameState*>    gameStates_;
+        std::vector<GameState*>              activeStates_;
         boost::shared_ptr<GameStateTreeNode> rootStateNode_;
         boost::shared_ptr<GameStateTreeNode> activeStateNode_;
 …
         Core*                           core_;
         Clock*                          gameClock_;
+        GameConfiguration*              configuration_;
+        bool                            abort_;
+        bool                            bChangingState_;
+        bool                            bAbort_;
         // variables for time statistics
         uint64_t                        statisticsStartTime_;
         std::list<statisticsTickInfo>   statisticsTickTimes_;
+        std::list<StatisticsTickInfo>   statisticsTickTimes_;
         uint32_t                        periodTime_;
         uint32_t                        periodTickTime_;
 …
         float                           avgTickTime_;
+        // config values
+        unsigned int                    statisticsRefreshCycle_;
+        unsigned int                    statisticsAvgLength_;
+        std::string                     levelName_;
+        static std::map<std::string, GameStateInfo> gameStateDeclarations_s;
+        static Game* singletonRef_s;        //!< Pointer to the Singleton
+    };
+        static std::map<std::string, GameState*> allStates_s;
+        static Game* singletonRef_s;        //!< Pointer to the Singleton
+        // tolua_begin
+    };
+    template <class T>
+    /*static*/ bool Game::declareGameState(const std::string& className, const std::string& stateName, bool bIgnoreTickTime, bool bGraphicsMode)
+    {
+        std::map<std::string, GameStateInfo>::const_iterator it = gameStateDeclarations_s.find(getLowercase(stateName));
+        if (it == gameStateDeclarations_s.end())
+        {
+            GameStateInfo& info = gameStateDeclarations_s[getLowercase(stateName)];
+            info.stateName = stateName;
+            info.className = className;
+            info.bIgnoreTickTime = bIgnoreTickTime;
+            info.bGraphicsMode = bGraphicsMode;
+        }
+        else
+        {
+            COUT(0) << "Error: Cannot declare two GameStates with the same name." << std::endl;
+            COUT(0) << "       Ignoring second one ('" << stateName << "')." << std::endl;
+        }
+        // Create a factory to delay GameState creation
+        GameStateFactory::createFactory<T>(className);
+        // just a required dummy return value
+        return true;
+    }
+}
+//tolua_end
 #endif /* _Game_H__ */

code/trunk/src/core/GameState.cc

-                      r3196
+                      r3280
         Constructor only initialises variables and sets the name permanently.
     */
     GameState::GameState(const std::string& name, bool countTickTime)
         : name_(name)
         , bCountTickTime_(countTickTime)
+    GameState::GameState(const GameStateConstrParams& params)
+        : name_(params.name)
+        , bIgnoreTickTime_(params.bIgnoreTickTime)
         , parent_(0)
+    {

code/trunk/src/core/GameState.h

-                      r3196
+                      r3280
     /**
     @brief
+        Helper class to group construction parameters for better genericity.
+    */
+    struct GameStateConstrParams
+    {
+        std::string name;
+        bool bIgnoreTickTime;
+    };
+    /**
+    @brief
         An implementation of a tree to manage game states.
         This leads to a certain hierarchy that is created at runtime.
 …
     public:
         GameState(const std::string& name, bool countTicktime = true);
+        GameState(const GameStateConstrParams& params);
         virtual ~GameState();
 …
         GameState* getParent()       const { return this->parent_; }
         bool getCountTickTime()      const { return this->bCountTickTime_; }
+        bool ignoreTickTime()        const { return this->bIgnoreTickTime_; }
         void addChild(GameState* state);
 …
     protected:
         virtual void activate() = 0;
         virtual void deactivate() = 0;
         virtual void update(const Clock& time) = 0;
+        virtual void activate() { }
+        virtual void deactivate() { }
+        virtual void update(const Clock& time) { }
     private:
 …
         const std::string                        name_;
         State                                    activity_;
         const bool                               bCountTickTime_;
+        const bool                               bIgnoreTickTime_;
         GameState*                               parent_;
         std::map<std::string, GameState*>        children_;

code/trunk/src/core/IRC.cc

r3196	r3280
68	68	{ COUT(1) << "Error while initializing Tcl (IRC): " << e.what(); }
69	69
70		this->nickname_ = "orx" + ~~getConvertedValue<int, std::string>((unsigned int)rand(~~));
	70	this->nickname_ = "orx" + multi_cast<std::string>(static_cast<unsigned int>(rand()));
71	71	TclThreadManager::execute(threadID, "set nickname " + this->nickname_);
72	72	TclThreadManager::execute(threadID, "source irc.tcl");

code/trunk/src/core/Identifier.cc

r3196	r3280
36	36	#include <ostream>
37	37
38		#include "util/String.h"
	38	#include "util/StringUtils.h"
39	39	#include "ConfigValueContainer.h"
40	40	#include "ConsoleCommand.h"

code/trunk/src/core/Language.cc

r3198	r3280
194	194	@return The filename
195	195	*/
196		~~const~~ std::string Language::getFilename(const std::string& language)
	196	std::string Language::getFilename(const std::string& language)
197	197	{
198	198	return std::string("translation_" + language + ".lang");

code/trunk/src/core/Language.h

-                      r2662
+                      r3280
     class _CoreExport Language
+    {
         friend class Core;
+        friend class CoreConfiguration;
         public:
 …
             void readTranslatedLanguageFile();
             void writeDefaultLanguageFile() const;
             static const std::string getFilename(const std::string& language);
+            static std::string getFilename(const std::string& language);
             LanguageEntry* createEntry(const LanguageEntryLabel& label, const std::string& entry);

code/trunk/src/core/LuaBind.cc

r3198	r3280
38	38
39	39	#include "util/Debug.h"
40		#include "util/String.h"
	40	#include "util/StringUtils.h"
41	41	#include "ToluaBindCore.h"
42	42	#include "Core.h"

code/trunk/src/core/OrxonoxClass.cc

-                      r3196
+                      r3280
     /** @brief Returns true if the objects class is of the given type or a derivative. */
     bool OrxonoxClass::isA(const SubclassIdentifier<class B>* identifier)
+    template <class B> bool OrxonoxClass::isA(const SubclassIdentifier<B>* identifier)
         { return this->getIdentifier()->isA(identifier->getIdentifier()); }
     /** @brief Returns true if the objects class is exactly of the given type. */
     bool OrxonoxClass::isExactlyA(const SubclassIdentifier<class B>* identifier)
+    template <class B> bool OrxonoxClass::isExactlyA(const SubclassIdentifier<B>* identifier)
         { return this->getIdentifier()->isExactlyA(identifier->getIdentifier()); }
     /** @brief Returns true if the objects class is a child of the given type. */
     bool OrxonoxClass::isChildOf(const SubclassIdentifier<class B>* identifier)
+    template <class B> bool OrxonoxClass::isChildOf(const SubclassIdentifier<B>* identifier)
         { return this->getIdentifier()->isChildOf(identifier->getIdentifier()); }
     /** @brief Returns true if the objects class is a direct child of the given type. */
     bool OrxonoxClass::isDirectChildOf(const SubclassIdentifier<class B>* identifier)
+    template <class B> bool OrxonoxClass::isDirectChildOf(const SubclassIdentifier<B>* identifier)
         { return this->getIdentifier()->isDirectChildOf(identifier->getIdentifier()); }
     /** @brief Returns true if the objects class is a parent of the given type. */
     bool OrxonoxClass::isParentOf(const SubclassIdentifier<class B>* identifier)
+    template <class B> bool OrxonoxClass::isParentOf(const SubclassIdentifier<B>* identifier)
         { return this->getIdentifier()->isParentOf(identifier->getIdentifier()); }
     /** @brief Returns true if the objects class is a direct parent of the given type. */
     bool OrxonoxClass::isDirectParentOf(const SubclassIdentifier<class B>* identifier)
+    template <class B> bool OrxonoxClass::isDirectParentOf(const SubclassIdentifier<B>* identifier)
         { return this->getIdentifier()->isDirectParentOf(identifier->getIdentifier()); }
     /** @brief Returns true if the objects class is of the given type or a derivative. */
     bool OrxonoxClass::isA(const SubclassIdentifier<class B> identifier)
+    template <class B> bool OrxonoxClass::isA(const SubclassIdentifier<B> identifier)
         { return this->getIdentifier()->isA(identifier.getIdentifier()); }
     /** @brief Returns true if the objects class is exactly of the given type. */
     bool OrxonoxClass::isExactlyA(const SubclassIdentifier<class B> identifier)
+    template <class B> bool OrxonoxClass::isExactlyA(const SubclassIdentifier<B> identifier)
         { return this->getIdentifier()->isExactlyA(identifier.getIdentifier()); }
     /** @brief Returns true if the objects class is a child of the given type. */
     bool OrxonoxClass::isChildOf(const SubclassIdentifier<class B> identifier)
+    template <class B> bool OrxonoxClass::isChildOf(const SubclassIdentifier<B> identifier)
         { return this->getIdentifier()->isChildOf(identifier.getIdentifier()); }
     /** @brief Returns true if the objects class is a direct child of the given type. */
     bool OrxonoxClass::isDirectChildOf(const SubclassIdentifier<class B> identifier)
+    template <class B> bool OrxonoxClass::isDirectChildOf(const SubclassIdentifier<B> identifier)
         { return this->getIdentifier()->isDirectChildOf(identifier.getIdentifier()); }
     /** @brief Returns true if the objects class is a parent of the given type. */
     bool OrxonoxClass::isParentOf(const SubclassIdentifier<class B> identifier)
+    template <class B> bool OrxonoxClass::isParentOf(const SubclassIdentifier<B> identifier)
         { return this->getIdentifier()->isParentOf(identifier.getIdentifier()); }
     /** @brief Returns true if the objects class is a direct parent of the given type. */
     bool OrxonoxClass::isDirectParentOf(const SubclassIdentifier<class B> identifier)
+    template <class B> bool OrxonoxClass::isDirectParentOf(const SubclassIdentifier<B> identifier)
         { return this->getIdentifier()->isDirectParentOf(identifier.getIdentifier()); }

code/trunk/src/core/OrxonoxClass.h

-                      r3196
+                      r3280
             bool isDirectParentOf(const Identifier* identifier);
             bool isA(const SubclassIdentifier<class B>* identifier);
             bool isExactlyA(const SubclassIdentifier<class B>* identifier);
             bool isChildOf(const SubclassIdentifier<class B>* identifier);
             bool isDirectChildOf(const SubclassIdentifier<class B>* identifier);
             bool isParentOf(const SubclassIdentifier<class B>* identifier);
             bool isDirectParentOf(const SubclassIdentifier<class B>* identifier);
+            template <class B> bool isA(const SubclassIdentifier<B>* identifier);
+            template <class B> bool isExactlyA(const SubclassIdentifier<B>* identifier);
+            template <class B> bool isChildOf(const SubclassIdentifier<B>* identifier);
+            template <class B> bool isDirectChildOf(const SubclassIdentifier<B>* identifier);
+            template <class B> bool isParentOf(const SubclassIdentifier<B>* identifier);
+            template <class B> bool isDirectParentOf(const SubclassIdentifier<B>* identifier);
             bool isA(const SubclassIdentifier<class B> identifier);
             bool isExactlyA(const SubclassIdentifier<class B> identifier);
             bool isChildOf(const SubclassIdentifier<class B> identifier);
             bool isDirectChildOf(const SubclassIdentifier<class B> identifier);
             bool isParentOf(const SubclassIdentifier<class B> identifier);
             bool isDirectParentOf(const SubclassIdentifier<class B> identifier);
+            template <class B> bool isA(const SubclassIdentifier<B> identifier);
+            template <class B> bool isExactlyA(const SubclassIdentifier<B> identifier);
+            template <class B> bool isChildOf(const SubclassIdentifier<B> identifier);
+            template <class B> bool isDirectChildOf(const SubclassIdentifier<B> identifier);
+            template <class B> bool isParentOf(const SubclassIdentifier<B> identifier);
+            template <class B> bool isDirectParentOf(const SubclassIdentifier<B> identifier);
             bool isA(const OrxonoxClass* object);

code/trunk/src/core/Shell.cc

-                      r3196
+                      r3280
         OutputHandler::getOutStream().setOutputBuffer(&this->outputBuffer_);
+        // Get a config file for the command history
+        this->commandHistoryConfigFileType_ = ConfigFileManager::getInstance().getNewConfigFileType();
+        ConfigFileManager::getInstance().setFilename(this->commandHistoryConfigFileType_, "commandHistory.ini");
         this->setConfigValues();
 …
     void Shell::setConfigValues()
+    {
+        SetConfigValue(maxHistoryLength_, 100).callback(this, &Shell::commandHistoryLengthChanged);
+        SetConfigValue(historyOffset_, 0).callback(this, &Shell::commandHistoryOffsetChanged);
+        SetConfigValueVector(commandHistory_, std::vector<std::string>());
+        SetConfigValueGeneric(commandHistoryConfigFileType_, maxHistoryLength_, 100)
+            .callback(this, &Shell::commandHistoryLengthChanged);
+        SetConfigValueGeneric(commandHistoryConfigFileType_, historyOffset_, 0)
+            .callback(this, &Shell::commandHistoryOffsetChanged);
+        SetConfigValueVectorGeneric(commandHistoryConfigFileType_, commandHistory_, std::vector<std::string>());
+    }

code/trunk/src/core/Shell.h

-                      r3196
+                      r3280
 #include <vector>
+#include "util/OutputBuffer.h"
+#include "input/InputBuffer.h"
 #include "OrxonoxClass.h"
+#include "input/InputBuffer.h"
+#include "util/OutputBuffer.h"
+#include "ConfigFileManager.h"
 namespace orxonox
 …
             bool bAddOutputLevel_;
+            ConfigFileType commandHistoryConfigFileType_;
             static Shell* singletonRef_s;
     };

code/trunk/src/core/TclBind.cc

r3196	r3280
34	34
35	35	#include "util/Debug.h"
36		#include "util/String.h"
	36	#include "util/StringUtils.h"
37	37	#include "CommandExecutor.h"
38	38	#include "ConsoleCommand.h"

code/trunk/src/core/TclThreadManager.cc

r3196	r3280
94	94	boost::mutex::scoped_lock bundles_lock(TclThreadManager::getInstance().bundlesMutex_);
95	95	TclThreadManager::getInstance().threadCounter_++;
96		std::string name = ~~getConvertedValue<unsigned int,~~ std::string>(TclThreadManager::getInstance().threadCounter_);
	96	std::string name = multi_cast<std::string>(TclThreadManager::getInstance().threadCounter_);
97	97
98	98	TclInterpreterBundle* bundle = new TclInterpreterBundle;
…	…
192	192	{
193	193	boost::mutex::scoped_lock queue_lock(TclThreadManager::getInstance().orxonoxInterpreterBundle_.queueMutex_);
194		output += ~~getConvertedValue<unsigned int,~~ std::string>(TclThreadManager::getInstance().orxonoxInterpreterBundle_.queue_.size());
	194	output += multi_cast<std::string>(TclThreadManager::getInstance().orxonoxInterpreterBundle_.queue_.size());
195	195	}
196	196	output += "\t\t";
…	…
201	201	for (std::map<unsigned int, TclInterpreterBundle*>::const_iterator it = TclThreadManager::getInstance().interpreterBundles_.begin(); it != TclThreadManager::getInstance().interpreterBundles_.end(); ++it)
202	202	{
203		std::string output = ~~getConvertedValue<unsigned int,~~ std::string>((*it).first);
	203	std::string output = multi_cast<std::string>((*it).first);
204	204	output += "\t\t";
205	205	{
206	206	boost::mutex::scoped_lock queue_lock((*it).second->queueMutex_);
207		output += ~~getConvertedValue<unsigned int,~~ std::string>((*it).second->queue_.size());
	207	output += multi_cast<std::string>((*it).second->queue_.size());
208	208	}
209	209	output += "\t\t";
…	…
342	342	else
343	343	{
344		this->error("Error: No Tcl-interpreter with ID " + ~~getConvertedValue<unsigned int,~~ std::string>(threadID) + " existing.");
	344	this->error("Error: No Tcl-interpreter with ID " + multi_cast<std::string>(threadID) + " existing.");
345	345	return 0;
346	346	}
…	…
355	355	output += " ";
356	356
357		output += ~~getConvertedValue<unsigned int,~~ std::string>(*it);
	357	output += multi_cast<std::string>(*it);
358	358	}
359	359	return output;
…	…
444	444	if (bundle->queue_.size() >= TCLTHREADMANAGER_MAX_QUEUE_LENGTH)
445	445	{
446		this->error("Error: Queue of Tcl-interpreter " + ~~getConvertedValue<unsigned int,~~ std::string>(threadID) + " is full, couldn't add command.");
	446	this->error("Error: Queue of Tcl-interpreter " + multi_cast<std::string>(threadID) + " is full, couldn't add command.");
447	447	return;
448	448	}
…	…
492	492	if (std::find(target->queriers_.begin(), target->queriers_.end(), target->id_) != target->queriers_.end())
493	493	{
494		this->error("Error: Circular query (" + this->dumpList(target->queriers_) + " -> " + getConvertedValue<unsigned int, std::string>(target->id_) + "), couldn't query Tcl-interpreter with ID " + getConvertedValue<unsigned int, std::string>(target->id_) + " from other interpreter with ID " + getConvertedValue<unsigned int, std::string>(querier->id_) + ".");
	494	this->error("Error: Circular query (" + this->dumpList(target->queriers_) + " -> " + multi_cast<std::string>(target->id_) + "), couldn't query Tcl-interpreter with ID " + multi_cast<std::string>(target->id_) + " from other interpreter with ID " + multi_cast<std::string>(querier->id_) + ".");
495	495	return false;
496	496	}
…	…
585	585	else
586	586	{
587		this->error("Error: Couldn't query Tcl-interpreter with ID " + ~~getConvertedValue<unsigned int,~~ std::string>(threadID) + ", interpreter is busy right now.");
	587	this->error("Error: Couldn't query Tcl-interpreter with ID " + multi_cast<std::string>(threadID) + ", interpreter is busy right now.");
588	588	}
589	589	}
…	…
665	665	catch (Tcl::tcl_error const &e)
666	666	{
667		TclThreadManager::getInstance().error("Tcl (ID " + ~~getConvertedValue<unsigned int,~~ std::string>(interpreterBundle->id_) + ") error: " + e.what());
	667	TclThreadManager::getInstance().error("Tcl (ID " + multi_cast<std::string>(interpreterBundle->id_) + ") error: " + e.what());
668	668	}
669	669	catch (std::exception const &e)
670	670	{
671		TclThreadManager::getInstance().error("Error while executing Tcl (ID " + ~~getConvertedValue<unsigned int,~~ std::string>(interpreterBundle->id_) + "): " + e.what());
	671	TclThreadManager::getInstance().error("Error while executing Tcl (ID " + multi_cast<std::string>(interpreterBundle->id_) + "): " + e.what());
672	672	}
673	673

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

-                      r2662
+                      r3280
 #include "util/Convert.h"
 #include "util/SubString.h"
 #include "util/String.h"
+#include "util/StringUtils.h"
 #include "util/Debug.h"
 #include "core/ConsoleCommand.h"
 …
                     '\\', false, '"', false, '(', ')', false, '\0');
                 KeybindMode::Enum mode = KeybindMode::None;
+                KeybindMode::Value mode = KeybindMode::None;
                 float paramModifier = 1.0f;
                 std::string commandStr = "";

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

-                      r2662
+                      r3280
         void parse();
         void readConfigValue(ConfigFileType configFile);
         bool execute(KeybindMode::Enum mode, float abs = 1.0f, float rel = 1.0f);
+        bool execute(KeybindMode::Value mode, float abs = 1.0f, float rel = 1.0f);
         //! Container to allow for better configValue support
 …
     };
     inline bool Button::execute(KeybindMode::Enum mode, float abs, float rel)
+    inline bool Button::execute(KeybindMode::Value mode, float abs, float rel)
+    {
         // execute all the parsed commands in the string

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

-                      r3196
+                      r3280
 #include "util/Convert.h"
 #include "util/Exception.h"
 #include "util/Debug.h"
+#include "util/ScopeGuard.h"
 #include "core/Clock.h"
 #include "core/CoreIncludes.h"
 …
     SetConsoleCommand(InputManager, ungrabMouse, true);
 #endif
     SetCommandLineSwitch(keyboard_no_grab);
+    SetCommandLineSwitch(keyboard_no_grab).information("Whether not to exclusively grab the keyboard");
     EmptyHandler InputManager::EMPTY_HANDLER;
 …
             windowHndStr << (unsigned int)windowHnd_;
             paramList.insert(std::make_pair(std::string("WINDOW"), windowHndStr.str()));
+#if defined(ORXONOX_PLATFORM_WINDOWS)
             //paramList.insert(std::make_pair(std::string("w32_mouse"), std::string("DISCL_NONEXCLUSIVE")));
             //paramList.insert(std::make_pair(std::string("w32_mouse"), std::string("DISCL_FOREGROUND")));
+#if defined ORXONOX_PLATFORM_LINUX
+            //paramList.insert(std::make_pair(std::string("w32_keyboard"), std::string("DISCL_NONEXCLUSIVE")));
+            //paramList.insert(std::make_pair(std::string("w32_keyboard"), std::string("DISCL_FOREGROUND")));
+#elif defined(ORXONOX_PLATFORM_LINUX)
             paramList.insert(std::make_pair(std::string("XAutoRepeatOn"), std::string("true")));
             paramList.insert(std::make_pair(std::string("x11_mouse_grab"), "true"));
 …
 #endif
+            inputSystem_ = OIS::InputManager::createInputSystem(paramList);
+            CCOUT(ORX_DEBUG) << "Created OIS input system" << std::endl;
+            _initialiseKeyboard();
+            try
+            {
+                inputSystem_ = OIS::InputManager::createInputSystem(paramList);
+                // Exception-safety
+                Loki::ScopeGuard guard = Loki::MakeGuard(OIS::InputManager::destroyInputSystem, inputSystem_);
+                CCOUT(ORX_DEBUG) << "Created OIS input system" << std::endl;
+                _initialiseKeyboard();
+                // Nothing below should throw anymore, dismiss the guard
+                guard.Dismiss();
+            }
+            catch (OIS::Exception& ex)
+            {
+                ThrowException(InitialisationFailed, "Could not initialise the input system: " << ex.what());
+            }
             _initialiseMouse();
 …
             if (joyStickSupport)
                 _initialiseJoySticks();
             // Do this anyway to also inform everything when a joystick was detached.
+            // Do this anyway to also inform when a joystick was detached.
             _configureJoySticks();
 …
         else
+        {
             ThrowException(InitialisationFailed, "No keyboard found!");
+            ThrowException(InitialisationFailed, "InputManager: No keyboard found, cannot proceed!");
+        }
+    }
 …
             else
+            {
                 CCOUT(ORX_WARNING) << "Warning: No mouse found!" << std::endl;
+                CCOUT(ORX_WARNING) << "Warning: No mouse found! Proceeding without mouse support." << std::endl;
+            }
+        }
 …
+        {
             CCOUT(ORX_WARNING) << "Warning: Failed to create an OIS mouse\n"
                 << "OIS error message: \"" << ex.eText << "\"" << std::endl;
+                << "OIS error message: \"" << ex.eText << "\"\n Proceeding without mouse support." << std::endl;
             mouse_ = 0;
+        }
 …
+            }
+        }
-        else
+        {
-            //CCOUT(ORX_WARNING) << "Warning: Joy stick support requested, but no joy stick was found" << std::endl;
+        }
+    }
 …
         if (internalState_ != Uninitialised)
+        {
+            CCOUT(3) << "Destroying ..." << std::endl;
+            // kick all active states 'nicely'
+            for (std::map<int, InputState*>::reverse_iterator rit = activeStates_.rbegin();
+                rit != activeStates_.rend(); ++rit)
+            {
+                (*rit).second->onLeave();
+            }
+            // Destroy calibrator helper handler and state
+            delete keyDetector_;
+            requestDestroyState("calibrator");
+            // Destroy KeyDetector and state
+            delete calibratorCallbackBuffer_;
+            requestDestroyState("detector");
+            // destroy the empty InputState
+            _destroyState(this->stateEmpty_);
+            // destroy all user InputStates
+            while (inputStatesByName_.size() > 0)
+                _destroyState((*inputStatesByName_.rbegin()).second);
+            // destroy the devices
+            _destroyKeyboard();
+            _destroyMouse();
+            _destroyJoySticks();
             try
+            {
-                CCOUT(3) << "Destroying ..." << std::endl;
-                // kick all active states 'nicely'
-                for (std::map<int, InputState*>::reverse_iterator rit = activeStates_.rbegin();
-                    rit != activeStates_.rend(); ++rit)
+                {
-                    (*rit).second->onLeave();
+                }
-                // Destroy calibrator helper handler and state
-                delete keyDetector_;
-                requestDestroyState("calibrator");
-                // Destroy KeyDetector and state
-                delete calibratorCallbackBuffer_;
-                requestDestroyState("detector");
-                // destroy the empty InputState
-                _destroyState(this->stateEmpty_);
-                // destroy all user InputStates
-                while (inputStatesByName_.size() > 0)
-                    _destroyState((*inputStatesByName_.rbegin()).second);
-                // destroy the devices
-                _destroyKeyboard();
-                _destroyMouse();
-                _destroyJoySticks();
                 OIS::InputManager::destroyInputSystem(inputSystem_);
+                CCOUT(3) << "Destroying done." << std::endl;
+            }
+            catch (OIS::Exception& ex)
+            {
+                CCOUT(1) << "An exception has occured while destroying:\n" << ex.what()
+                         << "This could lead to a possible memory/resource leak!" << std::endl;
+            }
+            catch (...)
+            {
+                CCOUT(1) << "OIS::InputManager destruction failed! Potential resource leak!" << std::endl;
+            }
+        }
 …
+    {
         assert(inputSystem_);
+        if (keyboard_)
+            inputSystem_->destroyInputObject(keyboard_);
+        keyboard_ = 0;
+        CCOUT(4) << "Keyboard destroyed." << std::endl;
+        try
+        {
+            if (keyboard_)
+                inputSystem_->destroyInputObject(keyboard_);
+            keyboard_ = 0;
+            CCOUT(4) << "Keyboard destroyed." << std::endl;
+        }
+        catch (...)
+        {
+            CCOUT(1) << "Keyboard destruction failed! Potential resource leak!" << std::endl;
+        }
+    }
 …
+    {
         assert(inputSystem_);
+        if (mouse_)
+            inputSystem_->destroyInputObject(mouse_);
+        mouse_ = 0;
+        CCOUT(4) << "Mouse destroyed." << std::endl;
+        try
+        {
+            if (mouse_)
+                inputSystem_->destroyInputObject(mouse_);
+            mouse_ = 0;
+            CCOUT(4) << "Mouse destroyed." << std::endl;
+        }
+        catch (...)
+        {
+            CCOUT(1) << "Mouse destruction failed! Potential resource leak!" << std::endl;
+        }
+    }
 …
             assert(inputSystem_);
             for (unsigned int i = 0; i < joySticksSize_; i++)
+                if (joySticks_[i] != 0)
+                    inputSystem_->destroyInputObject(joySticks_[i]);
+            {
+                try
+                {
+                    if (joySticks_[i] != 0)
+                        inputSystem_->destroyInputObject(joySticks_[i]);
+                }
+                catch (...)
+                {
+                    CCOUT(1) << "Joy stick destruction failed! Potential resource leak!" << std::endl;
+                }
+            }
             joySticks_.clear();

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

-                      r3196
+                      r3280
+        }
         // Get a new ConfigFileType from the ConfigFileManager
         this->configFile_ = ConfigFileManager::getInstance().getNewConfigFileType();
+        // We might not even load any bindings at all (KeyDetector for instance)
+        this->configFile_ = ConfigFileType::NoType;
         // initialise joy sticks separatly to allow for reloading
 …
         for (unsigned int iDev = 0; iDev < numberOfJoySticks_; iDev++)
+        {
             std::string deviceNumber = convertToString(iDev);
+            std::string deviceNumber = multi_cast<std::string>(iDev);
             // joy stick buttons
             for (unsigned int i = 0; i < JoyStickButtonCode::numberOfButtons; i++)
 …
         if (filename.empty())
             return;
+        if (this->configFile_ == ConfigFileType::NoType)
+        {
+            // Get a new ConfigFileType from the ConfigFileManager
+            this->configFile_ = ConfigFileManager::getInstance().getNewConfigFileType();
+        }
         ConfigFileManager::getInstance().setFilename(this->configFile_, filename);

code/trunk/src/network/NetworkPrereqs.h

r3214	r3280
132	132	namespace PacketFlag
133	133	{
134		enum ~~Enum~~
	134	enum Value
135	135	{
136	136	Reliable = 1,

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

-                      r3214
+                      r3280
 #define PACKET_FLAGS_ACK    0
 #define _PACKETID           0
 #define _ACKID              _PACKETID + sizeof(packet::ENUM::Type)
+#define _ACKID              _PACKETID + sizeof(packet::Type::Value)
 Acknowledgement::Acknowledgement( unsigned int id, unsigned int clientID )
 …
   flags_ = flags_ | PACKET_FLAGS_ACK;
   data_=new uint8_t[ getSize() ];
   *(ENUM::Type *)(data_ + _PACKETID ) = ENUM::Acknowledgement;
+  *(Type::Value *)(data_ + _PACKETID ) = Type::Acknowledgement;
   *(uint32_t *)(data_ + _ACKID ) = id;
   clientID_=clientID;

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

-                      r3214
+                      r3280
 #define   PACKET_FLAGS_CHAT PacketFlag::Reliable
 #define   _PACKETID         0
 const int _PLAYERID     =   _PACKETID + sizeof(ENUM::Type);
+const int _PLAYERID     =   _PACKETID + sizeof(Type::Value);
 #define   _MESSAGELENGTH    _PLAYERID + sizeof(uint32_t)
 #define   _MESSAGE          _MESSAGELENGTH + sizeof(uint32_t)
 …
   messageLength_ = message.length()+1;
   data_=new unsigned char[ getSize() ];
   *(ENUM::Type *)(data_ + _PACKETID ) = ENUM::Chat;
+  *(Type::Value *)(data_ + _PACKETID ) = Type::Chat;
   *(unsigned int *)(data_ + _PLAYERID ) = playerID;
   *(unsigned int *)(data_ + _MESSAGELENGTH ) = messageLength_;

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

r3214	r3280
74	74	//set the appropriate packet id
75	75	assert(this->data_);
76		(~~ENUM::Type )(this->data_ + _PACKETID ) = ENUM~~::ClassID;
	76	(Type::Value )(this->data_ + _PACKETID ) = Type::ClassID;
77	77
78	78	uint8_t *temp=data_+sizeof(uint32_t);

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

-                      r3214
+                      r3280
 #define PACKET_FLAG_DELETE  PacketFlag::Reliable
 #define _PACKETID           0
 #define _QUANTITY           _PACKETID + sizeof(ENUM::Type)
+#define _QUANTITY           _PACKETID + sizeof(Type::Value)
 #define _OBJECTIDS          _QUANTITY + sizeof(uint32_t)
 …
     return false;
   COUT(4) << "sending DeleteObjects: ";
   unsigned int size = sizeof(ENUM::Type) + sizeof(uint32_t)*(number+1);
+  unsigned int size = sizeof(Type::Value) + sizeof(uint32_t)*(number+1);
   data_ = new uint8_t[size];
   uint8_t *tdata = data_;
   *reinterpret_cast<ENUM::Type*>(tdata) = ENUM::DeleteObjects;
   tdata += sizeof(ENUM::Type);
+  *reinterpret_cast<Type::Value*>(tdata) = Type::DeleteObjects;
+  tdata += sizeof(Type::Value);
   *(uint32_t *)tdata = number;
   tdata += sizeof(uint32_t);

code/trunk/src/network/packet/FunctionCalls.cc

r3214	r3280
49	49	currentMemBlocks_ = 1;
50	50	data_=new uint8_t[ FUNCTIONCALLS_MEM_ALLOCATION ];
51		(~~ENUM::Type )(data_ + _PACKETID ) = ENUM~~::FunctionCalls;
	51	(Type::Value )(data_ + _PACKETID ) = Type::FunctionCalls;
52	52	(uint32_t)(data_+sizeof(uint32_t)) = 0; // set nrOfCalls to 0
53	53	}

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

r3214	r3280
68	68	//set the appropriate packet id
69	69	assert(this->data_);
70		(~~ENUM::Type )(this->data_ + _PACKETID ) = ENUM~~::FunctionIDs;
	70	(Type::Value )(this->data_ + _PACKETID ) = Type::FunctionIDs;
71	71
72	72	uint8_t *temp=data_+sizeof(uint32_t);

code/trunk/src/network/packet/Gamestate.h

r3214	r3280
47	47	class _NetworkExport GamestateHeader{
48	48	public:
49		GamestateHeader(uint8_t data){ assert(data); data_ = data; (uint32_t*)data_ = ~~ENUM~~::Gamestate; }
	49	GamestateHeader(uint8_t data){ assert(data); data_ = data; (uint32_t*)data_ = Type::Gamestate; }
50	50	GamestateHeader(uint8_t data, GamestateHeader h)
51	51	{ assert(data); data_=data; memcpy(data_, h->data_, getSize()); }

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

-                      r3214
+                      r3280
 Packet::Packet(){
   flags_ = PACKET_FLAG_DEFAULT;
   packetDirection_ = ENUM::Outgoing;
+  packetDirection_ = Direction::Outgoing;
   clientID_=0;
   data_=0;
 …
 Packet::Packet(uint8_t *data, unsigned int clientID){
   flags_ = PACKET_FLAG_DEFAULT;
   packetDirection_ = ENUM::Incoming;
+  packetDirection_ = Direction::Incoming;
   clientID_=clientID;
   data_=data;
 …
 bool Packet::send(){
   if(packetDirection_ != ENUM::Outgoing && packetDirection_ != ENUM::Bidirectional ){
+  if(packetDirection_ != Direction::Outgoing && packetDirection_ != Direction::Bidirectional ){
     assert(0);
     return false;
 …
+  }
 #ifndef NDEBUG
   switch( *(ENUM::Type *)(data_ + _PACKETID) )
+  switch( *(Type::Value *)(data_ + _PACKETID) )
+  {
     case ENUM::Acknowledgement:
     case ENUM::Chat:
     case ENUM::ClassID:
     case ENUM::Gamestate:
     case ENUM::Welcome:
     case ENUM::DeleteObjects:
     case ENUM::FunctionIDs:
     case ENUM::FunctionCalls:
+    case Type::Acknowledgement:
+    case Type::Chat:
+    case Type::ClassID:
+    case Type::Gamestate:
+    case Type::Welcome:
+    case Type::DeleteObjects:
+    case Type::FunctionIDs:
+    case Type::FunctionCalls:
       break;
     default:
 …
   unsigned int clientID = ClientInformation::findClient(&peer->address)->getID();
   Packet *p = 0;
   COUT(6) << "packet type: " << *(ENUM::Type *)&data[_PACKETID] << std::endl;
   switch( *(ENUM::Type *)(data + _PACKETID) )
+  COUT(6) << "packet type: " << *(Type::Value *)&data[_PACKETID] << std::endl;
+  switch( *(Type::Value *)(data + _PACKETID) )
+  {
     case ENUM::Acknowledgement:
+    case Type::Acknowledgement:
       COUT(5) << "ack" << std::endl;
       p = new Acknowledgement( data, clientID );
       break;
     case ENUM::Chat:
+    case Type::Chat:
       COUT(5) << "chat" << std::endl;
       p = new Chat( data, clientID );
       break;
     case ENUM::ClassID:
+    case Type::ClassID:
       COUT(5) << "classid" << std::endl;
       p = new ClassID( data, clientID );
       break;
     case ENUM::Gamestate:
+    case Type::Gamestate:
       COUT(5) << "gamestate" << std::endl;
       // TODO: remove brackets
       p = new Gamestate( data, clientID );
       break;
     case ENUM::Welcome:
+    case Type::Welcome:
       COUT(5) << "welcome" << std::endl;
       p = new Welcome( data, clientID );
       break;
     case ENUM::DeleteObjects:
+    case Type::DeleteObjects:
       COUT(5) << "deleteobjects" << std::endl;
       p = new DeleteObjects( data, clientID );
       break;
     case ENUM::FunctionCalls:
+    case Type::FunctionCalls:
       COUT(5) << "functionCalls" << std::endl;
       p = new FunctionCalls( data, clientID );
       break;
     case ENUM::FunctionIDs:
+    case Type::FunctionIDs:
       COUT(5) << "functionIDs" << std::endl;
       p = new FunctionIDs( data, clientID );

code/trunk/src/network/packet/Packet.h

-                      r3214
+                      r3280
 namespace packet{
 namespace ENUM{
   enum Direction{
+namespace Direction{
+  enum Value{
     Incoming,
     Outgoing,
     Bidirectional
   };
+  enum Type{
+}
+namespace Type{
+  enum Value{
     Acknowledgement,
     Chat,
 …
     uint32_t flags_;
     unsigned int clientID_;
     ENUM::Direction packetDirection_;
+    Direction::Value packetDirection_;
     /** Pointer to the data. Be careful when deleting it because it might
         point to a location that was allocated by ENet.

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

-                      r3214
+                      r3280
 #define PACKET_FLAGS_CLASSID  PacketFlag::Reliable
 #define _PACKETID             0
 #define _CLIENTID             _PACKETID + sizeof(ENUM::Type)
+#define _CLIENTID             _PACKETID + sizeof(Type::Value)
 #define _ENDIANTEST           _CLIENTID + sizeof(uint32_t)
 …
   data_=new uint8_t[ getSize() ];
   assert(data_);
   *(packet::ENUM::Type *)(data_ + _PACKETID ) = packet::ENUM::Welcome;
+  *(packet::Type::Value *)(data_ + _PACKETID ) = packet::Type::Welcome;
   *(uint32_t *)(data_ + _CLIENTID ) = static_cast<uint32_t>(clientID);
   *(uint32_t *)(data_ + _ENDIANTEST ) = 0xFEDC4321;
 …
 unsigned int Welcome::getSize() const{
   return sizeof(packet::ENUM::Type) + 2*sizeof(uint32_t);
+  return sizeof(packet::Type::Value) + 2*sizeof(uint32_t);
+}

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

r3214	r3280
65	65	this->dataSize_ = 0;
66	66	// set standard priority
67		this->setPriority( ~~priority::n~~ormal );
	67	this->setPriority( Priority::Normal );
68	68
69	69	// get creator id

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

-                      r3214
+                      r3280
+{
   namespace objectDirection{
     enum objectdirection{
       toclient=0x1,
       toserver=0x2,
       bidirectional=0x3
+  namespace ObjectDirection{
+    enum Value{
+      ToClient=0x1,
+      ToServer=0x2,
+      Bidirectional=0x3
     };
+  }
   namespace priority{
     enum prio{
       very_high   = -100,
       high        = -15,
       normal      = 0,
       low         = 15,
       very_low    = 100
+  namespace Priority{
+    enum Value{
+      VeryHigh    = -100,
+      High        = -15,
+      Normal      = 0,
+      Low         = 15,
+      VeryLow     = 100
     };
+  }

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

-                      r3214
+                      r3280
 namespace orxonox{
   namespace variableDirection{
     enum syncdirection{
       toclient=0x1,
       toserver=0x2
+  namespace VariableDirection{
+    enum Value{
+      ToClient=0x1,
+      ToServer=0x2
     };
+    enum bidirectional{
+      serverMaster=0x1,
+      clientMaster=0x2
+  }
+  namespace Bidirectionality{
+    enum Value{
+      ServerMaster=0x1,
+      ClientMaster=0x2
     };
+  }
 …
+  {
     public:
       SynchronisableVariable(T& variable, uint8_t syncDirection=variableDirection::toclient, NetworkCallbackBase *cb=0);
+      SynchronisableVariable(T& variable, uint8_t syncDirection=VariableDirection::ToClient, NetworkCallbackBase *cb=0);
       virtual ~SynchronisableVariable();
 …
+  {
     public:
       SynchronisableVariableBidirectional(T& variable, uint8_t master=variableDirection::serverMaster, NetworkCallbackBase *cb=0);
+      SynchronisableVariableBidirectional(T& variable, uint8_t master=Bidirectionality::ServerMaster, NetworkCallbackBase *cb=0);
       virtual ~SynchronisableVariableBidirectional();

code/trunk/src/orxonox/CMakeLists.txt

r3204	r3280
42	42	FIND_HEADER_FILES
43	43	TOLUA_FILES
	44	LevelManager.h
44	45	gui/GUIManager.h
45	46	objects/pickup/BaseItem.h

code/trunk/src/orxonox/CameraManager.cc

r3196	r3280
32	32	#include <OgreCompositorManager.h>
33	33
34		#include "util/String.h"
	34	#include "util/StringUtils.h"
35	35	#include "core/GameMode.h"
36	36	#include "core/ObjectList.h"

code/trunk/src/orxonox/GraphicsManager.cc

-                      r3196
+                      r3280
 #include <fstream>
 #include <boost/filesystem.hpp>
+#include <boost/shared_ptr.hpp>
 #include <OgreCompositorManager.h>
 …
 #include "SpecialConfig.h"
 #include "util/Exception.h"
 #include "util/String.h"
+#include "util/StringUtils.h"
 #include "util/SubString.h"
 #include "core/Clock.h"
 …
 namespace orxonox
+{
+    using boost::shared_ptr;
     class _OrxonoxExport OgreWindowEventListener : public Ogre::WindowEventListener
+    {
 …
         , renderWindow_(0)
         , viewport_(0)
         , ogreWindowEventListener_(0)
+        , ogreWindowEventListener_(new OgreWindowEventListener())
+    {
         RegisterObject(GraphicsManager);
 …
         singletonRef_s = this;
-        this->loaded_ = false;
         this->setConfigValues();
+    }
+    void GraphicsManager::initialise()
+    {
         // Ogre setup procedure
         setupOgre();
+        // load all the required plugins for Ogre
+        loadOgrePlugins();
+        // read resource declaration file
+        this->declareResources();
+        // Reads ogre config and creates the render window
+        this->loadRenderer();
+        // TODO: Spread this
+        this->initialiseResources();
+        // add console commands
+        FunctorMember<GraphicsManager>* functor1 = createFunctor(&GraphicsManager::printScreen);
+        functor1->setObject(this);
+        ccPrintScreen_ = createConsoleCommand(functor1, "printScreen");
+        CommandExecutor::addConsoleCommandShortcut(ccPrintScreen_);
+        this->loaded_ = true;
+        try
+        {
+            // load all the required plugins for Ogre
+            loadOgrePlugins();
+            // read resource declaration file
+            this->declareResources();
+            // Reads ogre config and creates the render window
+            this->loadRenderer();
+            // TODO: Spread this
+            this->initialiseResources();
+            // add console commands
+            FunctorMember<GraphicsManager>* functor1 = createFunctor(&GraphicsManager::printScreen);
+            functor1->setObject(this);
+            ccPrintScreen_ = createConsoleCommand(functor1, "printScreen");
+            CommandExecutor::addConsoleCommandShortcut(ccPrintScreen_);
+        }
+        catch (...)
+        {
+            // clean up
+            delete this->ogreRoot_;
+            delete this->ogreLogger_;
+            delete this->ogreWindowEventListener_;
+            throw;
+        }
+    }
 …
     GraphicsManager::~GraphicsManager()
+    {
+        if (this->loaded_)
+        {
+            delete this->ccPrintScreen_;
+            if (this->ogreWindowEventListener_)
+            {
+                // remove our WindowEventListener first to avoid bad calls after the window has been destroyed
+                Ogre::WindowEventUtilities::removeWindowEventListener(this->renderWindow_, this->ogreWindowEventListener_);
+                delete this->ogreWindowEventListener_;
+            }
+            // destroy render window
+//            Ogre::RenderSystem* renderer = this->ogreRoot_->getRenderSystem();
+//            renderer->destroyRenderWindow("Orxonox");
+            // HACK! This fixes an exit crash
+            Map::hackDestroyMap();
+            // unload all compositors
+            Ogre::CompositorManager::getSingleton().removeAll();
+            // Delete OGRE main control organ
+            delete this->ogreRoot_;
+            // delete the ogre log and the logManager (since we have created it in the first place).
+            this->ogreLogger_->getDefaultLog()->removeListener(this);
+            this->ogreLogger_->destroyLog(Ogre::LogManager::getSingleton().getDefaultLog());
+            delete this->ogreLogger_;
+        }
+/*
+        delete this->ccPrintScreen_;
+*/
+        // HACK! This fixes an exit crash
+        Map::hackDestroyMap();
+        // unload all compositors (this is only necessary because we don't yet destroy all resources!)
+        Ogre::CompositorManager::getSingleton().removeAll();
+        // Delete OGRE main control organ
+        delete this->ogreRoot_;
+        // delete the logManager (since we have created it in the first place).
+        delete this->ogreLogger_;
+        delete this->ogreWindowEventListener_;
         assert(singletonRef_s);
 …
     void GraphicsManager::update(const Clock& time)
+    {
+        if (this->loaded_)
+        {
+            Ogre::FrameEvent evt;
+            evt.timeSinceLastFrame = time.getDeltaTime();
+            evt.timeSinceLastEvent = time.getDeltaTime(); // note: same time, but shouldn't matter anyway
+            // don't forget to call _fireFrameStarted to OGRE to make sure
+            // everything goes smoothly
+            ogreRoot_->_fireFrameStarted(evt);
+            // Pump messages in all registered RenderWindows
+            // This calls the WindowEventListener objects.
+            Ogre::WindowEventUtilities::messagePump();
+            // make sure the window stays active even when not focused
+            // (probably only necessary on windows)
+            this->renderWindow_->setActive(true);
+            // render
+            ogreRoot_->_updateAllRenderTargets();
+            // again, just to be sure OGRE works fine
+            ogreRoot_->_fireFrameEnded(evt); // note: uses the same time as _fireFrameStarted
+        }
+        Ogre::FrameEvent evt;
+        evt.timeSinceLastFrame = time.getDeltaTime();
+        evt.timeSinceLastEvent = time.getDeltaTime(); // note: same time, but shouldn't matter anyway
+        // don't forget to call _fireFrameStarted to OGRE to make sure
+        // everything goes smoothly
+        ogreRoot_->_fireFrameStarted(evt);
+        // Pump messages in all registered RenderWindows
+        // This calls the WindowEventListener objects.
+        Ogre::WindowEventUtilities::messagePump();
+        // make sure the window stays active even when not focused
+        // (probably only necessary on windows)
+        this->renderWindow_->setActive(true);
+        // render
+        ogreRoot_->_updateAllRenderTargets();
+        // again, just to be sure OGRE works fine
+        ogreRoot_->_fireFrameEnded(evt); // note: uses the same time as _fireFrameStarted
+    }
 …
         // create a new logManager
         // Ogre::Root will detect that we've already created a Log
         ogreLogger_ = new Ogre::LogManager();
+        std::auto_ptr<Ogre::LogManager> logger(new Ogre::LogManager());
         COUT(4) << "Ogre LogManager created" << std::endl;
         // create our own log that we can listen to
         Ogre::Log *myLog;
         myLog = ogreLogger_->createLog(ogreLogFilepath.string(), true, false, false);
+        myLog = logger->createLog(ogreLogFilepath.string(), true, false, false);
         COUT(4) << "Ogre Log created" << std::endl;
 …
         // Leave plugins file empty. We're going to do that part manually later
         ogreRoot_ = new Ogre::Root("", ogreConfigFilepath.string(), ogreLogFilepath.string());
+        // In case that new Root failed the logger gets destroyed because of the std::auto_ptr
+        ogreLogger_ = logger.release();
         COUT(3) << "Ogre set up done." << std::endl;
 …
         if (!ogreRoot_->restoreConfig())
             if (!ogreRoot_->showConfigDialog())
                 ThrowException(InitialisationFailed, "Could not show Ogre configuration dialogue.");
+                ThrowException(InitialisationFailed, "OGRE graphics configuration dialogue failed.");
         CCOUT(4) << "Creating render window" << std::endl;
 …
         this->renderWindow_ = ogreRoot_->initialise(true, "Orxonox");
-        this->ogreWindowEventListener_ = new OgreWindowEventListener();
         Ogre::WindowEventUtilities::addWindowEventListener(this->renderWindow_, ogreWindowEventListener_);

code/trunk/src/orxonox/GraphicsManager.h

-                      r3196
+                      r3280
         void setConfigValues();
-        void initialise();
         void update(const Clock& time);
 …
     private:
-        bool                loaded_;
         Ogre::Root*         ogreRoot_;                 //!< Ogre's root
         Ogre::LogManager*   ogreLogger_;
         Ogre::RenderWindow* renderWindow_;             //!< the one and only render window
         Ogre::Viewport*     viewport_;                 //!< default full size viewport
         OgreWindowEventListener* ogreWindowEventListener_;
+        OgreWindowEventListener* ogreWindowEventListener_; //!< Pimpl to hide OgreWindowUtilities.h
         // config values

code/trunk/src/orxonox/LevelManager.cc

-                      r3196
+                      r3280
 #include <map>
+#include "core/CommandLine.h"
+#include "core/ConfigValueIncludes.h"
+#include "core/CoreIncludes.h"
 #include "PlayerManager.h"
 #include "objects/Level.h"
 …
 namespace orxonox
+{
+    SetCommandLineArgument(level, "").shortcut("l").information("Default level file (overrides LevelManager::defaultLevelName_ configValue)");
     LevelManager* LevelManager::singletonRef_s = 0;
 …
         assert(singletonRef_s == 0);
         singletonRef_s = this;
+        RegisterRootObject(LevelManager);
+        this->setConfigValues();
+        // check override
+        if (!CommandLine::getArgument("level")->hasDefaultValue())
+        {
+            ModifyConfigValue(defaultLevelName_, tset, CommandLine::getValue("level").getString());
+        }
+    }
 …
         assert(singletonRef_s != 0);
         singletonRef_s = 0;
+    }
+    void LevelManager::setConfigValues()
+    {
+        SetConfigValue(defaultLevelName_, "presentation_dm.oxw")
+            .description("Sets the preselection of the level in the main menu.");
+    }
 …
+        }
+    }
+    void LevelManager::setDefaultLevel(const std::string& levelName)
+    {
+        ModifyConfigValue(defaultLevelName_, set, levelName);
+    }
+    const std::string& LevelManager::getDefaultLevel()
+    {
+        return defaultLevelName_;
+    }
+}

code/trunk/src/orxonox/LevelManager.h

-                      r3196
+                      r3280
 #include <cassert>
 #include <list>
+#include "core/OrxonoxClass.h"
+// tolua_begin
 namespace orxonox
+{
     class _OrxonoxExport LevelManager
+    {
+    // tolua_end
+        : public OrxonoxClass
+    { // tolua_export
         public:
             LevelManager();
             virtual ~LevelManager();
+            void setConfigValues();
             void requestActivity(Level* level);
 …
             Level* getActiveLevel();
+            void setDefaultLevel(const std::string& levelName); //tolua_export
+            const std::string& getDefaultLevel(); //tolua_export
             static LevelManager* getInstancePtr() { return singletonRef_s; }
             static LevelManager& getInstance() { assert(singletonRef_s); return *singletonRef_s; }
+            static LevelManager& getInstance() { assert(singletonRef_s); return *singletonRef_s; } // tolua_export
         private:
 …
             std::list<Level*> levels_s;
+            // config values
+            std::string defaultLevelName_;
             static LevelManager* singletonRef_s;
     };
+}
+    }; // tolua_export
+} // tolua_export
 #endif /* _LevelManager_H__ */

code/trunk/src/orxonox/Main.cc

-                      r3196
+                      r3280
 #include "util/Debug.h"
 #include "core/Identifier.h"
+#include "util/Exception.h"
 #include "core/Game.h"
 …
 #endif
+{
+    using namespace orxonox;
+    Game* game = 0;
+    try
+    {
         orxonox::Game orxonox(argc, argv);
+        game = new Game(argc, argv);
         orxonox.setStateHierarchy(
+        game->setStateHierarchy(
         "root"
         " graphics"
 …
         );
+        orxonox.run();
+        game->requestState("root");
+    }
+    catch (const std::exception& ex)
+    {
+        COUT(0) << "Orxonox failed to initialise: " << ex.what() << std::endl;
+        COUT(0) << "Terminating program." << std::endl;
+        return 1;
+    }
+    catch (...)
+    {
+        COUT(0) << "Orxonox failed to initialise: " << std::endl;
+        COUT(0) << "Terminating program." << std::endl;
+        return 1;
+    }
+        // destroy the GameStates created pre-mainly
+        orxonox::Game::destroyStates();
+    } // orxonox gets destroyed right here!
+    // Clean up class hierarchy stuff (identifiers, xmlport, configvalue, consolecommand)
+    // Needs to be done after Game destructor because of ~OrxonoxClass
+    orxonox::Identifier::destroyAllIdentifiers();
+    game->run();
+    delete game;
     return 0;

code/trunk/src/orxonox/OrxonoxPrereqs.h

-                      r3196
+                      r3280
     namespace LODParticle
+    {
         enum LOD
+        enum Value
+        {
             off = 0,
             low = 1,
             normal = 2,
             high = 3
+            Off = 0,
+            Low = 1,
+            Normal = 2,
+            High = 3
         };
+    }
 …
+{
     class DefaultLogger;
+    class Logger;
     class LuaScriptModule;

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

-                      r3196
+                      r3280
 namespace orxonox
+{
     AddGameState(GSClient, "client");
+    DeclareGameState(GSClient, "client", false, true);
     SetCommandLineArgument(ip, "127.0.0.1").information("#.#.#.#");
+    SetCommandLineArgument(ip, "127.0.0.1").information("Sever IP as strin in the form #.#.#.#");
     GSClient::GSClient(const std::string& name)
         : GameState(name)
+    GSClient::GSClient(const GameStateConstrParams& params)
+        : GameState(params)
         , client_(0)
+    {

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

r3196	r3280
40	40	{
41	41	public:
42		GSClient(const ~~std::string& name~~);
	42	GSClient(const GameStateConstrParams& params);
43	43	~GSClient();
44	44

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

-                      r3205
+                      r3280
     const unsigned int MAX_COMMAND_LENGTH = 255;
     AddGameState(GSDedicated, "dedicated");
+    DeclareGameState(GSDedicated, "dedicated", false, false);
     termios* GSDedicated::originalTerminalSettings_;
     GSDedicated::GSDedicated(const std::string& name)
         : GameState(name)
+    GSDedicated::GSDedicated(const GameStateConstrParams& params)
+        : GameState(params)
         , server_(0)
         , timeSinceLastUpdate_(0)

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

r3198	r3280
48	48	{
49	49	public:
50		GSDedicated(const ~~std::string& name~~);
	50	GSDedicated(const GameStateConstrParams& params);
51	51	~GSDedicated();
52	52

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

-                      r3196
+                      r3280
 namespace orxonox
+{
     AddGameState(GSGraphics, "graphics", false);
     GSGraphics::GSGraphics(const std::string& name, bool countTickTime)
         : GameState(name, countTickTime)
+    DeclareGameState(GSGraphics, "graphics", true, true);
+    GSGraphics::GSGraphics(const GameStateConstrParams& params)
+        : GameState(params)
         , inputManager_(0)
         , console_(0)
 …
         setConfigValues();
         // initialise graphics manager. Doesn't load the render window yet!
+        // Load OGRE including the render window
         this->graphicsManager_ = new GraphicsManager();
-        this->graphicsManager_->initialise();
         // load debug overlay
 …
     void GSGraphics::toggleGUI()
+    {
             GUIManager::getInstance().executeCode("toggleGUI()");
+        GUIManager::getInstance().executeCode("toggleGUI()");
+    }

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

r3196	r3280
52	52	{
53	53	public:
54		GSGraphics(const ~~std::string& name, bool countTickTime~~);
	54	GSGraphics(const GameStateConstrParams& params);
55	55	~GSGraphics();
56	56	void setConfigValues();

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

r3196	r3280
36	36	namespace orxonox
37	37	{
38		~~AddGameState(GSIOConsole, "ioConsole"~~);
	38	DeclareGameState(GSIOConsole, "ioConsole", false, false);
39	39
40		GSIOConsole::GSIOConsole(const ~~std::string& name~~)
41		: GameState(~~name~~)
	40	GSIOConsole::GSIOConsole(const GameStateConstrParams& params)
	41	: GameState(params)
42	42	{
43	43	}

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

r2896	r3280
38	38	{
39	39	public:
40		GSIOConsole(const ~~std::string& name~~);
	40	GSIOConsole(const GameStateConstrParams& params);
41	41	~GSIOConsole();
42	42

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

-                      r3196
+                      r3280
 #include "core/input/KeyBinder.h"
 #include "core/Clock.h"
-#include "core/CommandLine.h"
 #include "core/ConsoleCommand.h"
 #include "core/ConfigValueIncludes.h"
 …
 namespace orxonox
+{
+    AddGameState(GSLevel, "level");
+    SetCommandLineArgument(level, "").shortcut("l");
+    DeclareGameState(GSLevel, "level", false, true);
     SetConsoleCommand(GSLevel, showIngameGUI, true);
     XMLFile* GSLevel::startFile_s = NULL;
     GSLevel::GSLevel(const std::string& name)
         : GameState(name)
+    GSLevel::GSLevel(const GameStateConstrParams& params)
+        : GameState(params)
         , keyBinder_(0)
         , gameInputState_(0)
 …
         , radar_(0)
         , cameraManager_(0)
-        , levelManager_(0)
+    {
         RegisterObject(GSLevel);
 …
         if (GameMode::isMaster())
+        {
-            // create the global LevelManager
-            this->levelManager_ = new LevelManager();
             this->loadLevel();
+        }
 …
+        }
-        if (this->levelManager_)
+        {
-            delete this->levelManager_;
-            this->levelManager_ = 0;
+        }
         if (this->playerManager_)
+        {
 …
         // call the loader
         COUT(0) << "Loading level..." << std::endl;
+        std::string levelName;
+        CommandLine::getValue("level", &levelName);
+        if (levelName == "")
+            startFile_s = new XMLFile(Core::getMediaPathString() + "levels" + '/' + Game::getInstance().getLevel());
+        else
+            startFile_s = new XMLFile(Core::getMediaPathString() + "levels" + '/' + levelName);
+        startFile_s = new XMLFile(Core::getMediaPathString() + "levels" + '/' + LevelManager::getInstance().getDefaultLevel());
         Loader::open(startFile_s);
+    }

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

-                      r3196
+                      r3280
+    {
     public:
         GSLevel(const std::string& name);
+        GSLevel(const GameStateConstrParams& params);
         ~GSLevel();
         void setConfigValues();
 …
         Radar*                radar_;                   //!< represents the Radar (not the HUD part)
         CameraManager*        cameraManager_;           //!< camera manager for this level
-        LevelManager*         levelManager_;            //!< global level manager
         PlayerManager*        playerManager_;           //!< player manager for this level
         QuestManager*         questManager_;

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

-                      r3196
+                      r3280
 namespace orxonox
+{
     AddGameState(GSMainMenu, "mainMenu");
+    DeclareGameState(GSMainMenu, "mainMenu", false, true);
     GSMainMenu::GSMainMenu(const std::string& name)
         : GameState(name)
+    GSMainMenu::GSMainMenu(const GameStateConstrParams& params)
+        : GameState(params)
         , inputState_(0)
+    {
 …
         // show main menu
         GUIManager::getInstance().showGUI("mainmenu_2");
+        GUIManager::getInstance().showGUI("mainmenu_3");
         GUIManager::getInstance().setCamera(this->camera_);
         GraphicsManager::getInstance().setCamera(this->camera_);

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

r3196	r3280
40	40	{
41	41	public:
42		GSMainMenu(const ~~std::string& name~~);
	42	GSMainMenu(const GameStateConstrParams& params);
43	43	~GSMainMenu();
44	44

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

-                      r3196
+                      r3280
 #include "interfaces/TimeFactorListener.h"
 #include "interfaces/Tickable.h"
+#include "LevelManager.h"
 namespace orxonox
+{
     AddGameState(GSRoot, "root", false);
     SetCommandLineSwitch(console);
+    DeclareGameState(GSRoot, "root", true, false);
+    SetCommandLineSwitch(console).information("Start in console mode (text IO only)");
     // Shortcuts for easy direct loading
     SetCommandLineSwitch(server);
     SetCommandLineSwitch(client);
     SetCommandLineSwitch(dedicated);
     SetCommandLineSwitch(standalone);
     GSRoot::GSRoot(const std::string& name, bool countTickTime)
         : GameState(name, countTickTime)
+    SetCommandLineSwitch(server).information("Start in server mode");
+    SetCommandLineSwitch(client).information("Start in client mode");
+    SetCommandLineSwitch(dedicated).information("Start in dedicated server mode");
+    SetCommandLineSwitch(standalone).information("Start in standalone mode");
+    GSRoot::GSRoot(const GameStateConstrParams& params)
+        : GameState(params)
         , timeFactor_(1.0f)
         , bPaused_(false)
 …
+        }
+        // create the global LevelManager
+        this->levelManager_ = new LevelManager();
         // Load level directly?
         bool loadLevel = false;
 …
+        }
 */
+        delete this->levelManager_;
+    }

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

-                      r3196
+                      r3280
+    {
     public:
         GSRoot(const std::string& name, bool countTickTime);
+        GSRoot(const GameStateConstrParams& params);
         ~GSRoot();
 …
     private:
         float                 timeFactor_;       //!< A factor that sets the gamespeed. 1 is normal.
+        float                 timeFactor_;              //!< A factor that sets the gamespeed. 1 is normal.
         bool                  bPaused_;
         float                 timeFactorPauseBackup_;
+        LevelManager*         levelManager_;            //!< global level manager
         // console commands

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

-                      r3196
+                      r3280
 namespace orxonox
+{
     AddGameState(GSServer, "server");
+    DeclareGameState(GSServer, "server", false, true);
     SetCommandLineArgument(port, 55556).shortcut("p").information("0-65535");
+    SetCommandLineArgument(port, 55556).shortcut("p").information("Network communication port to be used 0-65535 (default: 55556)");
     GSServer::GSServer(const std::string& name)
         : GameState(name)
+    GSServer::GSServer(const GameStateConstrParams& params)
+        : GameState(params)
         , server_(0)
+    {

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

r3196	r3280
40	40	{
41	41	public:
42		GSServer(const ~~std::string& name~~);
	42	GSServer(const GameStateConstrParams& params);
43	43	~GSServer();
44	44

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

r3196	r3280
34	34	namespace orxonox
35	35	{
36		~~AddGameState(GSStandalone, "standalone"~~);
	36	DeclareGameState(GSStandalone, "standalone", false, true);
37	37
38		GSStandalone::GSStandalone(const ~~std::string& name~~)
39		: GameState(~~name~~)
	38	GSStandalone::GSStandalone(const GameStateConstrParams& params)
	39	: GameState(params)
40	40	{
41	41	}

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

r2896	r3280
38	38	{
39	39	public:
40		GSStandalone(const ~~std::string& name~~);
	40	GSStandalone(const GameStateConstrParams& params);
41	41	~GSStandalone();
42	42

code/trunk/src/orxonox/gui/GUIManager.cc

-                      r3196
+                      r3280
 #endif
+#include "util/Debug.h"
 #include "util/Exception.h"
+#include "util/OrxAssert.h"
 #include "core/Core.h"
 #include "core/Clock.h"
 …
 namespace orxonox
+{
+    class CEGUILogger : public CEGUI::DefaultLogger
+    {
+    public:
+            void logEvent(const CEGUI::String& message, CEGUI::LoggingLevel level = CEGUI::Standard)
+        {
+            int orxonoxLevel;
+            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;
+                default: OrxAssert(false, "CEGUI log level out of range, inpect immediately!");
+            }
+            OutputHandler::getOutStream().setOutputLevel(orxonoxLevel)
+                << "CEGUI: " << message << std::endl;
+            CEGUI::DefaultLogger::logEvent(message, level);
+        }
+    };
     static CEGUI::MouseButton convertButton(MouseButtonCode::ByEnum button);
     GUIManager* GUIManager::singletonRef_s = 0;
 …
                 // Create our own logger to specify the filepath
                 this->ceguiLogger_ = new DefaultLogger();
+                this->ceguiLogger_ = new CEGUILogger();
                 this->ceguiLogger_->setLogFilename(Core::getLogPathString() + "cegui.log");
                 // set the log level according to ours (translate by subtracting 1)

code/trunk/src/orxonox/gui/GUIManager.h

r3196	r3280
123	123	CEGUI::ResourceProvider* resourceProvider_; //!< CEGUI's resource provider
124	124	CEGUI::LuaScriptModule* scriptModule_; //!< CEGUI's script module to use Lua
125		CEGUI::DefaultLogger* ceguiLogger_; //!< CEGUI's logger to be able to log CEGUI errors in our log
	125	CEGUI::Logger* ceguiLogger_; //!< CEGUI's logger to be able to log CEGUI errors in our log
126	126	CEGUI::System* guiSystem_; //!< CEGUI's main system
127	127	lua_State* luaState_; //!< Lua state, access point to the Lua engine

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

r3196	r3280
33	33	#include <OgreEntity.h>
34	34
35		#include "util/String.h"
	35	#include "util/StringUtils.h"
36	36	#include "core/CoreIncludes.h"
37	37	#include "tools/DynamicLines.h"

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

Property svn:mergeinfo changed (with no actual effect on merging)

code/trunk/src/orxonox/objects/GlobalShader.cc

r3196	r3280
66	66	void GlobalShader::registerVariables()
67	67	{
68		registerVariable(this->bVisible_, ~~variableDirection::toc~~lient, new NetworkCallback<GlobalShader>(this, &GlobalShader::changedVisibility));
69		registerVariable(const_cast<std::string&>(this->shader_.getCompositor()), ~~variableDirection::toc~~lient, new NetworkCallback<Shader>(&this->shader_, &Shader::changedCompositor));
	68	registerVariable(this->bVisible_, VariableDirection::ToClient, new NetworkCallback<GlobalShader>(this, &GlobalShader::changedVisibility));
	69	registerVariable(const_cast<std::string&>(this->shader_.getCompositor()), VariableDirection::ToClient, new NetworkCallback<Shader>(&this->shader_, &Shader::changedCompositor));
70	70	}
71	71

code/trunk/src/orxonox/objects/Level.cc

-                      r3196
+                      r3280
     void Level::registerVariables()
+    {
         registerVariable(this->xmlfilename_, variableDirection::toclient, new NetworkCallback<Level>(this, &Level::networkcallback_applyXMLFile));
         registerVariable(this->name_,        variableDirection::toclient, new NetworkCallback<Level>(this, &Level::changedName));
         registerVariable(this->description_, variableDirection::toclient);
+        registerVariable(this->xmlfilename_, VariableDirection::ToClient, new NetworkCallback<Level>(this, &Level::networkcallback_applyXMLFile));
+        registerVariable(this->name_,        VariableDirection::ToClient, new NetworkCallback<Level>(this, &Level::changedName));
+        registerVariable(this->description_, VariableDirection::ToClient);
+    }

code/trunk/src/orxonox/objects/Scene.cc

-                      r3196
+                      r3280
     void Scene::registerVariables()
+    {
         registerVariable(this->skybox_,             variableDirection::toclient, new NetworkCallback<Scene>(this, &Scene::networkcallback_applySkybox));
         registerVariable(this->ambientLight_,       variableDirection::toclient, new NetworkCallback<Scene>(this, &Scene::networkcallback_applyAmbientLight));
         registerVariable(this->negativeWorldRange_, variableDirection::toclient, new NetworkCallback<Scene>(this, &Scene::networkcallback_negativeWorldRange));
         registerVariable(this->positiveWorldRange_, variableDirection::toclient, new NetworkCallback<Scene>(this, &Scene::networkcallback_positiveWorldRange));
         registerVariable(this->gravity_,            variableDirection::toclient, new NetworkCallback<Scene>(this, &Scene::networkcallback_gravity));
         registerVariable(this->bHasPhysics_,        variableDirection::toclient, new NetworkCallback<Scene>(this, &Scene::networkcallback_hasPhysics));
         registerVariable(this->bShadows_,           variableDirection::toclient, new NetworkCallback<Scene>(this, &Scene::networkcallback_applyShadows));
+        registerVariable(this->skybox_,             VariableDirection::ToClient, new NetworkCallback<Scene>(this, &Scene::networkcallback_applySkybox));
+        registerVariable(this->ambientLight_,       VariableDirection::ToClient, new NetworkCallback<Scene>(this, &Scene::networkcallback_applyAmbientLight));
+        registerVariable(this->negativeWorldRange_, VariableDirection::ToClient, new NetworkCallback<Scene>(this, &Scene::networkcallback_negativeWorldRange));
+        registerVariable(this->positiveWorldRange_, VariableDirection::ToClient, new NetworkCallback<Scene>(this, &Scene::networkcallback_positiveWorldRange));
+        registerVariable(this->gravity_,            VariableDirection::ToClient, new NetworkCallback<Scene>(this, &Scene::networkcallback_gravity));
+        registerVariable(this->bHasPhysics_,        VariableDirection::ToClient, new NetworkCallback<Scene>(this, &Scene::networkcallback_hasPhysics));
+        registerVariable(this->bShadows_,           VariableDirection::ToClient, new NetworkCallback<Scene>(this, &Scene::networkcallback_applyShadows));
+    }

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

r3196	r3280
57	57	void BoxCollisionShape::registerVariables()
58	58	{
59		registerVariable(this->halfExtents_, ~~variableDirection::toc~~lient, new NetworkCallback<CollisionShape>(this, &CollisionShape::updateShape));
	59	registerVariable(this->halfExtents_, VariableDirection::ToClient, new NetworkCallback<CollisionShape>(this, &CollisionShape::updateShape));
60	60	}
61	61

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

r3196	r3280
77	77	void CollisionShape::registerVariables()
78	78	{
79		registerVariable(this->parentID_, ~~variableDirection::toc~~lient, new NetworkCallback<CollisionShape>(this, &CollisionShape::parentChanged));
	79	registerVariable(this->parentID_, VariableDirection::ToClient, new NetworkCallback<CollisionShape>(this, &CollisionShape::parentChanged));
80	80	}
81	81

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

r3196	r3280
57	57	void ConeCollisionShape::registerVariables()
58	58	{
59		registerVariable(this->radius_, ~~variableDirection::toc~~lient, new NetworkCallback<CollisionShape>(this, &CollisionShape::updateShape));
60		registerVariable(this->height_, ~~variableDirection::toc~~lient, new NetworkCallback<CollisionShape>(this, &CollisionShape::updateShape));
	59	registerVariable(this->radius_, VariableDirection::ToClient, new NetworkCallback<CollisionShape>(this, &CollisionShape::updateShape));
	60	registerVariable(this->height_, VariableDirection::ToClient, new NetworkCallback<CollisionShape>(this, &CollisionShape::updateShape));
61	61	}
62	62

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

r3196	r3280
58	58	void PlaneCollisionShape::registerVariables()
59	59	{
60		registerVariable(this->normal_, ~~variableDirection::toc~~lient, new NetworkCallback<CollisionShape>(this, &CollisionShape::updateShape));
61		registerVariable(this->offset_, ~~variableDirection::toc~~lient, new NetworkCallback<CollisionShape>(this, &CollisionShape::updateShape));
	60	registerVariable(this->normal_, VariableDirection::ToClient, new NetworkCallback<CollisionShape>(this, &CollisionShape::updateShape));
	61	registerVariable(this->offset_, VariableDirection::ToClient, new NetworkCallback<CollisionShape>(this, &CollisionShape::updateShape));
62	62	}
63	63

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

r3196	r3280
56	56	void SphereCollisionShape::registerVariables()
57	57	{
58		registerVariable(this->radius_, ~~variableDirection::toc~~lient, new NetworkCallback<CollisionShape>(this, &CollisionShape::updateShape));
	58	registerVariable(this->radius_, VariableDirection::ToClient, new NetworkCallback<CollisionShape>(this, &CollisionShape::updateShape));
59	59	}
60	60

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

-                      r3196
+                      r3280
             switch (base->getState())
+            {
                 case BaseState::controlTeam1:
+                case BaseState::ControlTeam1:
                     team1 = 0;
                     break;
                 case BaseState::controlTeam2:
+                case BaseState::ControlTeam2:
                     team1 = 1;
                     break;
                 case BaseState::uncontrolled:
+                case BaseState::Uncontrolled:
                 default:
                     team1 = -1;
 …
             switch (base->getState())
+            {
                 case BaseState::controlTeam1:
+                case BaseState::ControlTeam1:
                     team2 = 0;
                     break;
                 case BaseState::controlTeam2:
+                case BaseState::ControlTeam2:
                     team2 = 1;
                     break;
                 case BaseState::uncontrolled:
+                case BaseState::Uncontrolled:
                 default:
                     team2 = -1;

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

r3196	r3280
45	45	namespace PlayerState
46	46	{
47		enum ~~Enum~~
	47	enum Value
48	48	{
49	49	Uninitialized,
…	…
57	57	{
58	58	PlayerInfo* info_;
59		PlayerState::~~Enum~~ state_;
	59	PlayerState::Value state_;
60	60	int frags_;
61	61	int killed_;

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

r3196	r3280
66	66	if (teamnr == 0)
67	67	{
68		base->setState(BaseState::controlTeam1);
	68	base->setState(BaseState::ControlTeam1);
69	69	this->gtinfo_.sendAnnounceMessage("The red team captured a base");
70	70	}
71	71	if (teamnr == 1)
72	72	{
73		base->setState(BaseState::controlTeam2);
	73	base->setState(BaseState::ControlTeam2);
74	74	this->gtinfo_.sendAnnounceMessage("The blue team captured a base");
75	75	}
…	…
107	107	switch (base->getState())
108	108	{
109		case BaseState::controlTeam1:
	109	case BaseState::ControlTeam1:
110	110	teamnrbase = 0;
111	111	break;
112		case BaseState::controlTeam2:
	112	case BaseState::ControlTeam2:
113	113	teamnrbase = 1;
114	114	break;
115		case BaseState::uncontrolled:
	115	case BaseState::Uncontrolled:
116	116	default:
117	117	teamnrbase = -1;
…	…
155	155	for (std::set<TeamBaseMatchBase*>::const_iterator it = this->bases_.begin(); it != this->bases_.end(); ++it)
156	156	{
157		if((*it)->getState() == BaseState::controlTeam1)
	157	if((*it)->getState() == BaseState::ControlTeam1)
158	158	{
159	159	amountControlled++;
160	160	}
161		if((*it)->getState() == BaseState::controlTeam2)
	161	if((*it)->getState() == BaseState::ControlTeam2)
162	162	{
163	163	amountControlled2++;
…	…
241	241	for (std::set<TeamBaseMatchBase*>::const_iterator it = this->bases_.begin(); it != this->bases_.end(); ++it)
242	242	{
243		if ((*it)->getState() == BaseState::controlTeam1 && team == 0)
	243	if ((*it)->getState() == BaseState::ControlTeam1 && team == 0)
244	244	count++;
245		if ((*it)->getState() == BaseState::controlTeam2 && team == 1)
	245	if ((*it)->getState() == BaseState::ControlTeam2 && team == 1)
246	246	count++;
247	247	}
…	…
253	253	{
254	254	this->bases_.insert(base);
255		base->setState(BaseState::uncontrolled);
	255	base->setState(BaseState::Uncontrolled);
256	256	}
257	257

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

r3196	r3280
173	173	if ( gameTime_ <= timesequence_ && gameTime_ > 0)
174	174	{
175		std::string message = ~~convertToString~~(timesequence_) + " seconds left!";
	175	std::string message = multi_cast<std::string>(timesequence_) + " seconds left!";
176	176	/*
177	177	COUT(0) << message << std::endl;

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

-                      r3196
+                      r3280
     void GametypeInfo::registerVariables()
+    {
         registerVariable(this->bStarted_,               variableDirection::toclient);
         registerVariable(this->bEnded_,                 variableDirection::toclient);
         registerVariable(this->startCountdown_,         variableDirection::toclient);
         registerVariable(this->bStartCountdownRunning_, variableDirection::toclient);
         registerVariable(this->hudtemplate_,            variableDirection::toclient);
+        registerVariable(this->bStarted_,               VariableDirection::ToClient);
+        registerVariable(this->bEnded_,                 VariableDirection::ToClient);
+        registerVariable(this->startCountdown_,         VariableDirection::ToClient);
+        registerVariable(this->bStartCountdownRunning_, VariableDirection::ToClient);
+        registerVariable(this->hudtemplate_,            VariableDirection::ToClient);
+    }

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

-                      r3196
+                      r3280
     void HumanPlayer::registerVariables()
+    {
         registerVariable(this->synchronize_nick_, variableDirection::toserver, new NetworkCallback<HumanPlayer>(this, &HumanPlayer::networkcallback_changednick));
+        registerVariable(this->synchronize_nick_, VariableDirection::ToServer, new NetworkCallback<HumanPlayer>(this, &HumanPlayer::networkcallback_changednick));
         registerVariable(this->clientID_,           variableDirection::toclient, new NetworkCallback<HumanPlayer>(this, &HumanPlayer::networkcallback_clientIDchanged));
         registerVariable(this->server_initialized_, variableDirection::toclient, new NetworkCallback<HumanPlayer>(this, &HumanPlayer::networkcallback_server_initialized));
         registerVariable(this->client_initialized_, variableDirection::toserver, new NetworkCallback<HumanPlayer>(this, &HumanPlayer::networkcallback_client_initialized));
+        registerVariable(this->clientID_,           VariableDirection::ToClient, new NetworkCallback<HumanPlayer>(this, &HumanPlayer::networkcallback_clientIDchanged));
+        registerVariable(this->server_initialized_, VariableDirection::ToClient, new NetworkCallback<HumanPlayer>(this, &HumanPlayer::networkcallback_server_initialized));
+        registerVariable(this->client_initialized_, VariableDirection::ToServer, new NetworkCallback<HumanPlayer>(this, &HumanPlayer::networkcallback_client_initialized));
+    }
 …
             if (!GameMode::isMaster())
                 this->setObjectMode(objectDirection::bidirectional);
+                this->setObjectMode(ObjectDirection::Bidirectional);
             else
                 this->setName(this->nick_);

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

-                      r3196
+                      r3280
     void PlayerInfo::registerVariables()
+    {
         registerVariable(this->name_,                 variableDirection::toclient, new NetworkCallback<PlayerInfo>(this, &PlayerInfo::changedName));
         registerVariable(this->controllableEntityID_, variableDirection::toclient, new NetworkCallback<PlayerInfo>(this, &PlayerInfo::networkcallback_changedcontrollableentityID));
         registerVariable(this->bReadyToSpawn_,        variableDirection::toserver);
         registerVariable(this->gtinfoID_,             variableDirection::toclient, new NetworkCallback<PlayerInfo>(this, &PlayerInfo::networkcallback_changedgtinfoID));
+        registerVariable(this->name_,                 VariableDirection::ToClient, new NetworkCallback<PlayerInfo>(this, &PlayerInfo::changedName));
+        registerVariable(this->controllableEntityID_, VariableDirection::ToClient, new NetworkCallback<PlayerInfo>(this, &PlayerInfo::networkcallback_changedcontrollableentityID));
+        registerVariable(this->bReadyToSpawn_,        VariableDirection::ToServer);
+        registerVariable(this->gtinfoID_,             VariableDirection::ToClient, new NetworkCallback<PlayerInfo>(this, &PlayerInfo::networkcallback_changedgtinfoID));
+    }

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

-                      r3196
+                      r3280
     void Engine::registerVariables()
+    {
         registerVariable(this->shipID_, variableDirection::toclient, new NetworkCallback<Engine>(this, &Engine::networkcallback_shipID));
         registerVariable(this->speedFactor_, variableDirection::toclient);
         registerVariable(this->boostFactor_, variableDirection::toclient);
         registerVariable(this->maxSpeedFront_,     variableDirection::toclient);
         registerVariable(this->maxSpeedBack_,      variableDirection::toclient);
         registerVariable(this->maxSpeedLeftRight_, variableDirection::toclient);
         registerVariable(this->maxSpeedUpDown_,    variableDirection::toclient);
         registerVariable(this->accelerationFront_,     variableDirection::toclient);
         registerVariable(this->accelerationBrake_,     variableDirection::toclient);
         registerVariable(this->accelerationBack_,      variableDirection::toclient);
         registerVariable(this->accelerationLeftRight_, variableDirection::toclient);
         registerVariable(this->accelerationUpDown_,    variableDirection::toclient);
+        registerVariable(this->shipID_, VariableDirection::ToClient, new NetworkCallback<Engine>(this, &Engine::networkcallback_shipID));
+        registerVariable(this->speedFactor_, VariableDirection::ToClient);
+        registerVariable(this->boostFactor_, VariableDirection::ToClient);
+        registerVariable(this->maxSpeedFront_,     VariableDirection::ToClient);
+        registerVariable(this->maxSpeedBack_,      VariableDirection::ToClient);
+        registerVariable(this->maxSpeedLeftRight_, VariableDirection::ToClient);
+        registerVariable(this->maxSpeedUpDown_,    VariableDirection::ToClient);
+        registerVariable(this->accelerationFront_,     VariableDirection::ToClient);
+        registerVariable(this->accelerationBrake_,     VariableDirection::ToClient);
+        registerVariable(this->accelerationBack_,      VariableDirection::ToClient);
+        registerVariable(this->accelerationLeftRight_, VariableDirection::ToClient);
+        registerVariable(this->accelerationUpDown_,    VariableDirection::ToClient);
+    }

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

r3196	r3280
82	82	void MultiStateEngine::registerVariables()
83	83	{
84		registerVariable(this->state_, ~~variableDirection::tos~~erver);
	84	registerVariable(this->state_, VariableDirection::ToServer);
85	85	}
86	86
…	…
91	91	if (this->getShip()->hasLocalController())
92	92	{
93		this->setObjectMode(~~objectDirection::b~~idirectional);
	93	this->setObjectMode(ObjectDirection::Bidirectional);
94	94
95	95	const Vector3& direction = this->getDirection();

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

-                      r3196
+                      r3280
         if (this->addTo(pawn))
+        {
             std::map<ModifierType::Enum, float>::iterator it;
+            std::map<ModifierType::Value, float>::iterator it;
             for (it = this->additiveModifiers_.begin(); it != this->additiveModifiers_.end(); it++)
 …
         if (this->removeFrom(pawn))
+        {
             std::map<ModifierType::Enum, float>::iterator it;
+            std::map<ModifierType::Value, float>::iterator it;
             for (it = this->additiveModifiers_.begin(); it != this->additiveModifiers_.end(); it++)
 …
         @return Returns the additive modifier for type (or 0 if not exists).
     */
     float ModifierPickup::getAdditiveModifier(ModifierType::Enum type) const
+    {
         std::map<ModifierType::Enum, float>::const_iterator it = this->additiveModifiers_.find(type);
+    float ModifierPickup::getAdditiveModifier(ModifierType::Value type) const
+    {
+        std::map<ModifierType::Value, float>::const_iterator it = this->additiveModifiers_.find(type);
         if (it != this->additiveModifiers_.end())
             return (*it).second;
 …
         @return Returns the multiplicative modifier for type (or 1 if not exists).
     */
     float ModifierPickup::getMultiplicativeModifier(ModifierType::Enum type) const
+    {
         std::map<ModifierType::Enum, float>::const_iterator it = this->multiplicativeModifiers_.find(type);
+    float ModifierPickup::getMultiplicativeModifier(ModifierType::Value type) const
+    {
+        std::map<ModifierType::Value, float>::const_iterator it = this->multiplicativeModifiers_.find(type);
         if (it != this->multiplicativeModifiers_.end())
             return (*it).second;
 …
         @param value The new additive modifier for type.
     */
     void ModifierPickup::setAdditiveModifier(ModifierType::Enum type, float value)
+    void ModifierPickup::setAdditiveModifier(ModifierType::Value type, float value)
+    {
         if (this->additiveModifiers_.find(type) == this->additiveModifiers_.end())
             this->additiveModifiers_.insert( std::pair<ModifierType::Enum, float>(type, value) );
+            this->additiveModifiers_.insert( std::pair<ModifierType::Value, float>(type, value) );
         else
             this->additiveModifiers_[type] = value;
 …
         @param value The new multiplicative modifier for type.
     */
     void ModifierPickup::setMultiplicativeModifier(ModifierType::Enum type, float value)
+    void ModifierPickup::setMultiplicativeModifier(ModifierType::Value type, float value)
+    {
         if (this->multiplicativeModifiers_.find(type) == this->multiplicativeModifiers_.end())
             this->multiplicativeModifiers_.insert( std::pair<ModifierType::Enum, float>(type, value) );
+            this->multiplicativeModifiers_.insert( std::pair<ModifierType::Value, float>(type, value) );
         else
             this->multiplicativeModifiers_[type] = value;

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

-                      r3196
+                      r3280
         void timerCallback(Pawn* pawn);     //!< Method called when the timer runs out.
     private:
         float getAdditiveModifier(ModifierType::Enum type) const;               //!< Get the additive modifier for a given ModifierType.
         float getMultiplicativeModifier(ModifierType::Enum type) const;         //!< Get the multiplicative modifier for a given ModifierType.
         void setAdditiveModifier(ModifierType::Enum type, float value);         //!< Set the additive modifier for a given ModifierType.
         void setMultiplicativeModifier(ModifierType::Enum type, float value);   //!< Set the multiplicative modifier for a given ModifierType
+        float getAdditiveModifier(ModifierType::Value type) const;               //!< Get the additive modifier for a given ModifierType.
+        float getMultiplicativeModifier(ModifierType::Value type) const;         //!< Get the multiplicative modifier for a given ModifierType.
+        void setAdditiveModifier(ModifierType::Value type, float value);         //!< Set the additive modifier for a given ModifierType.
+        void setMultiplicativeModifier(ModifierType::Value type, float value);   //!< Set the multiplicative modifier for a given ModifierType
         std::map<ModifierType::Enum, float> additiveModifiers_;                 //!< Map of additive modifiers, indexed by ModifierType.
         std::map<ModifierType::Enum, float> multiplicativeModifiers_;           //!< Map of multiplicative modifiers, indexed by ModifierType.
+        std::map<ModifierType::Value, float> additiveModifiers_;                 //!< Map of additive modifiers, indexed by ModifierType.
+        std::map<ModifierType::Value, float> multiplicativeModifiers_;           //!< Map of multiplicative modifiers, indexed by ModifierType.
         float duration_;                                                        //!< Duration of this pickup's effect (0 for unlimited).

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

r3196	r3280
44	44	@brief Gives the available types for modifiers.
45	45	*/
46		enum ~~Enum~~
	46	enum Value
47	47	{
48	48	Unknown = 0,

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

-                      r3196
+                      r3280
+{
     typedef std::pair<std::multimap<std::string, BaseItem*>::iterator, std::multimap<std::string, BaseItem*>::iterator> item_range;
     typedef std::pair<std::multimap<ModifierType::Enum, float>::iterator, std::multimap<ModifierType::Enum, float>::iterator> modifier_range;
+    typedef std::pair<std::multimap<ModifierType::Value, float>::iterator, std::multimap<ModifierType::Value, float>::iterator> modifier_range;
     //! Constructor
 …
         @param value Value for the modifier.
     */
     void PickupCollection::addAdditiveModifier(ModifierType::Enum type, float value)
+    {
         this->additiveModifiers_.insert( std::pair<ModifierType::Enum, float>(type, value) );
+    void PickupCollection::addAdditiveModifier(ModifierType::Value type, float value)
+    {
+        this->additiveModifiers_.insert( std::pair<ModifierType::Value, float>(type, value) );
+    }
     /**
 …
         @return Returns the sum of the additive modifiers of the type.
     */
     float PickupCollection::getAdditiveModifier(ModifierType::Enum type)
+    float PickupCollection::getAdditiveModifier(ModifierType::Value type)
+    {
         float v = 0.0f;
 …
         modifier_range range = this->additiveModifiers_.equal_range(type);
         for (std::multimap<ModifierType::Enum, float>::iterator it = range.first; it != range.second && it != this->additiveModifiers_.end(); it++)
+        for (std::multimap<ModifierType::Value, float>::iterator it = range.first; it != range.second && it != this->additiveModifiers_.end(); it++)
+        {
             v += (*it).second;
 …
         @param value Value which is to be removed.
     */
     void PickupCollection::removeAdditiveModifier(ModifierType::Enum type, float value)
+    void PickupCollection::removeAdditiveModifier(ModifierType::Value type, float value)
+    {
         modifier_range range = this->additiveModifiers_.equal_range(type);
         for (std::multimap<ModifierType::Enum, float>::iterator it = range.first; it != range.second && it != this->additiveModifiers_.end(); it++)
+        for (std::multimap<ModifierType::Value, float>::iterator it = range.first; it != range.second && it != this->additiveModifiers_.end(); it++)
+        {
             if ((*it).second == value)
 …
         @param value Value for the modifier.
     */
     void PickupCollection::addMultiplicativeModifier(ModifierType::Enum type, float value)
+    {
         this->multiplicativeModifiers_.insert( std::pair<ModifierType::Enum, float>(type, value) );
+    void PickupCollection::addMultiplicativeModifier(ModifierType::Value type, float value)
+    {
+        this->multiplicativeModifiers_.insert( std::pair<ModifierType::Value, float>(type, value) );
+    }
     /**
 …
         @return Returns the product of the multiplicative modifiers of the type.
     */
     float PickupCollection::getMultiplicativeModifier(ModifierType::Enum type)
+    float PickupCollection::getMultiplicativeModifier(ModifierType::Value type)
+    {
         float v = 1.0f;
         modifier_range range = this->multiplicativeModifiers_.equal_range(type);
         for (std::multimap<ModifierType::Enum, float>::iterator it = range.first; it != range.second && it != this->multiplicativeModifiers_.end(); it++)
+        for (std::multimap<ModifierType::Value, float>::iterator it = range.first; it != range.second && it != this->multiplicativeModifiers_.end(); it++)
+        {
             v *= (*it).second;
 …
         @param value Value which is to be removed.
     */
     void PickupCollection::removeMultiplicativeModifier(ModifierType::Enum type, float value)
+    void PickupCollection::removeMultiplicativeModifier(ModifierType::Value type, float value)
+    {
         modifier_range range = this->multiplicativeModifiers_.equal_range(type);
         for (std::multimap<ModifierType::Enum, float>::iterator it = range.first; it != range.second && it != this->multiplicativeModifiers_.end(); it++)
+        for (std::multimap<ModifierType::Value, float>::iterator it = range.first; it != range.second && it != this->multiplicativeModifiers_.end(); it++)
+        {
             if ((*it).second == value)
 …
         @return Returns the value after being processed.
     */
     float PickupCollection::processModifiers(ModifierType::Enum type, float inputValue, bool addBeforeMultiplication)
+    float PickupCollection::processModifiers(ModifierType::Value type, float inputValue, bool addBeforeMultiplication)
+    {
         float outputValue = inputValue;
 …
         @return Returns the value after being processed.
     */
     Vector3 PickupCollection::processModifiers(ModifierType::Enum type, Vector3 inputValue, bool addBeforeMultiplication)
+    Vector3 PickupCollection::processModifiers(ModifierType::Value type, Vector3 inputValue, bool addBeforeMultiplication)
+    {
         Vector3 outputValue = inputValue;

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

-                      r3196
+                      r3280
         void useItem(UsableItem* item);                                             //!< Use a usable item.
         void addAdditiveModifier(ModifierType::Enum type, float value);             //!< Add an additive modifier.
         void addMultiplicativeModifier(ModifierType::Enum type, float value);       //!< Add a multiplicative modifier.
+        void addAdditiveModifier(ModifierType::Value type, float value);             //!< Add an additive modifier.
+        void addMultiplicativeModifier(ModifierType::Value type, float value);       //!< Add a multiplicative modifier.
         float getAdditiveModifier(ModifierType::Enum type);                         //!< Get total additive modifier.
         float getMultiplicativeModifier(ModifierType::Enum type);                   //!< Get total multiplicative modifier.
+        float getAdditiveModifier(ModifierType::Value type);                         //!< Get total additive modifier.
+        float getMultiplicativeModifier(ModifierType::Value type);                   //!< Get total multiplicative modifier.
         void removeAdditiveModifier(ModifierType::Enum type, float value);          //!< Remove an additive modifier.
         void removeMultiplicativeModifier(ModifierType::Enum type, float value);    //!< Remove a multiplicative modifier.
+        void removeAdditiveModifier(ModifierType::Value type, float value);          //!< Remove an additive modifier.
+        void removeMultiplicativeModifier(ModifierType::Value type, float value);    //!< Remove a multiplicative modifier.
         float processModifiers(ModifierType::Enum type, float inputValue, bool addBeforeMultiplication = false);        //!< Apply the modifiers to a float.
         Vector3 processModifiers(ModifierType::Enum type, Vector3 inputValue, bool addBeforeMultiplication = false);    //!< Apply the modifiers to a Vector3.
+        float processModifiers(ModifierType::Value type, float inputValue, bool addBeforeMultiplication = false);        //!< Apply the modifiers to a float.
+        Vector3 processModifiers(ModifierType::Value type, Vector3 inputValue, bool addBeforeMultiplication = false);    //!< Apply the modifiers to a Vector3.
         /**
 …
         bool bBlockRemovals_;   //!< Whether to block direct removals through remove().
         std::multimap<ModifierType::Enum, float> additiveModifiers_;        //!< Contains additive modifiers (indexed by ModifierType).
         std::multimap<ModifierType::Enum, float> multiplicativeModifiers_;  //!< Contains multiplicative modifiers (indexed by ModifierType).
+        std::multimap<ModifierType::Value, float> additiveModifiers_;        //!< Contains additive modifiers (indexed by ModifierType).
+        std::multimap<ModifierType::Value, float> multiplicativeModifiers_;  //!< Contains multiplicative modifiers (indexed by ModifierType).
         std::multimap<std::string, BaseItem*> items_;                       //!< Map of items in the collection (indexed by pickupIdentifier of the items).

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

r3196	r3280
147	147	return false;
148	148	}
149		return (this->isInactive(player) && !(this->status_ == ~~questStatus::completed \|\| this->status_ == questStatus::f~~ailed));
	149	return (this->isInactive(player) && !(this->status_ == QuestStatus::Completed \|\| this->status_ == QuestStatus::Failed));
150	150	}
151	151
…	…
189	189	Throws an Exception if player is NULL.
190	190	*/
191		~~questStatus::Enum~~ GlobalQuest::getStatus(const PlayerInfo* player) const
	191	QuestStatus::Value GlobalQuest::getStatus(const PlayerInfo* player) const
192	192	{
193	193	if(player == NULL) //!< We don't want NULL-Pointers!
…	…
203	203	}
204	204
205		return ~~questStatus::i~~nactive;
	205	return QuestStatus::Inactive;
206	206	}
207	207
…	…
217	217	Returns false if player is NULL.
218	218	*/
219		bool GlobalQuest::setStatus(PlayerInfo* player, const ~~questStatus::Enum~~ & status)
	219	bool GlobalQuest::setStatus(PlayerInfo* player, const QuestStatus::Value & status)
220	220	{
221	221	if(player == NULL) //!< We don't want NULL-Pointers!

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

-                      r3196
+                      r3280
             virtual bool isCompletable(const PlayerInfo* player) const; //!< Checks whether the Quest can be completed.
             virtual questStatus::Enum getStatus(const PlayerInfo* player) const; //!< Returns the status of the Quest for a specific player.
+            virtual QuestStatus::Value getStatus(const PlayerInfo* player) const; //!< Returns the status of the Quest for a specific player.
             virtual bool setStatus(PlayerInfo* player, const questStatus::Enum & status); //!< Sets the status for a specific player.
+            virtual bool setStatus(PlayerInfo* player, const QuestStatus::Value & status); //!< Sets the status for a specific player.
         private:
             std::set<PlayerInfo*> players_; //!< The set of players which possess this Quest.
             questStatus::Enum status_; //!< The status of this Quest.
+            QuestStatus::Value status_; //!< The status of this Quest.
             std::list<QuestEffect*> rewards_; //!< Reward QuestEffects only invoked on the player completing the Quest.

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

r3196	r3280
176	176	Throws an Exception if player is NULL.
177	177	*/
178		~~questStatus::Enum~~ LocalQuest::getStatus(const PlayerInfo* player) const
	178	QuestStatus::Value LocalQuest::getStatus(const PlayerInfo* player) const
179	179	{
180	180	if(player == NULL) //!< No player has no defined status.
…	…
183	183	}
184	184
185		std::map<const PlayerInfo*, ~~questStatus::Enum~~>::const_iterator it = this->playerStatus_.find(player);
	185	std::map<const PlayerInfo*, QuestStatus::Value>::const_iterator it = this->playerStatus_.find(player);
186	186	if (it != this->playerStatus_.end()) //!< If there is a player in the map.
187	187	{
…	…
189	189	}
190	190
191		return ~~questStatus::i~~nactive; //!< If the player is not yet in the map, that means the status of the quest form him is 'inactive'.
	191	return QuestStatus::Inactive; //!< If the player is not yet in the map, that means the status of the quest form him is 'inactive'.
192	192	}
193	193
…	…
203	203	Returns false if player is NULL.
204	204	*/
205		bool LocalQuest::setStatus(PlayerInfo* player, const ~~questStatus::Enum~~ & status)
	205	bool LocalQuest::setStatus(PlayerInfo* player, const QuestStatus::Value & status)
206	206	{
207	207	if(player == NULL) //!< We can't set a status for no player.

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

-                      r3196
+                      r3280
             virtual bool isCompletable(const PlayerInfo* player) const; //!< Checks whether the Quest can be completed.
             virtual questStatus::Enum getStatus(const PlayerInfo* player) const; //!< Returns the status of the Quest for a specific player.
             virtual bool setStatus(PlayerInfo* player, const questStatus::Enum & status); //!< Sets the status for a specific player.
+            virtual QuestStatus::Value getStatus(const PlayerInfo* player) const; //!< Returns the status of the Quest for a specific player.
+            virtual bool setStatus(PlayerInfo* player, const QuestStatus::Value & status); //!< Sets the status for a specific player.
         private:
             std::map<const PlayerInfo*, questStatus::Enum> playerStatus_; //!< List of the status for each player, with the Player-pointer as key.
+            std::map<const PlayerInfo*, QuestStatus::Value> playerStatus_; //!< List of the status for each player, with the Player-pointer as key.
     };

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

r3196	r3280
302	302	bool Quest::isInactive(const PlayerInfo* player) const
303	303	{
304		return this->getStatus(player) == ~~questStatus::i~~nactive;
	304	return this->getStatus(player) == QuestStatus::Inactive;
305	305	}
306	306
…	…
318	318	{
319	319
320		return this->getStatus(player) == ~~questStatus::a~~ctive;
	320	return this->getStatus(player) == QuestStatus::Active;
321	321	}
322	322
…	…
333	333	bool Quest::isFailed(const PlayerInfo* player) const
334	334	{
335		return this->getStatus(player) == ~~questStatus::f~~ailed;
	335	return this->getStatus(player) == QuestStatus::Failed;
336	336	}
337	337
…	…
348	348	bool Quest::isCompleted(const PlayerInfo* player) const
349	349	{
350		return this->getStatus(player) == ~~questStatus::c~~ompleted;
	350	return this->getStatus(player) == QuestStatus::Completed;
351	351	}
352	352
…	…
362	362	{
363	363	QuestListener::advertiseStatusChange(this->listeners_, "fail"); //!< Tells the QuestListeners, that the status has changed to failed.
364		this->setStatus(player, ~~questStatus::f~~ailed);
	364	this->setStatus(player, QuestStatus::Failed);
365	365
366	366	COUT(4) << "Quest {" << this->getId() << "} is failed for player: " << player << " ." <<std::endl;
…	…
381	381	{
382	382	QuestListener::advertiseStatusChange(this->listeners_, "complete"); //!< Tells the QuestListeners, that the status has changed to completed.
383		this->setStatus(player, ~~questStatus::c~~ompleted);
	383	this->setStatus(player, QuestStatus::Completed);
384	384
385	385	COUT(4) << "Quest {" << this->getId() << "} is completed for player: " << player << " ." <<std::endl;
…	…
409	409	QuestListener::advertiseStatusChange(this->listeners_, "start"); //!< Tells the QuestListeners, that the status has changed to active.
410	410
411		this->setStatus(player, ~~questStatus::a~~ctive);
	411	this->setStatus(player, QuestStatus::Active);
412	412
413	413	this->getDescription()->sendAddQuestNotification();

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

-                      r3196
+                      r3280
 namespace orxonox
+{
     namespace questStatus
+    namespace QuestStatus
+    {
         //!Different states of a Quest.
         enum Enum
+        enum Value
+        {
             inactive,
             active,
             failed,
             completed
+            Inactive,
+            Active,
+            Failed,
+            Completed
         };
+    }
 …
                 { return this->completeEffects_; }
             virtual questStatus::Enum getStatus(const PlayerInfo* player) const = 0; //!< Returns the status of the Quest for a specific player.
             virtual bool setStatus(PlayerInfo* player, const questStatus::Enum & status) = 0; //!< Changes the status for a specific player.
+            virtual QuestStatus::Value getStatus(const PlayerInfo* player) const = 0; //!< Returns the status of the Quest for a specific player.
+            virtual bool setStatus(PlayerInfo* player, const QuestStatus::Value & status) = 0; //!< Changes the status for a specific player.
         private:

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

-                      r3196
+                      r3280
         RegisterObject(QuestEffectBeacon);
         this->status_ = QuestEffectBeaconStatus::active;
+        this->status_ = QuestEffectBeaconStatus::Active;
         this->times_ = INFINITE_TIME;
+    }
 …
         if(activate)
+        {
         this->status_ = QuestEffectBeaconStatus::active;
         return true;
+        }
         this->status_ = QuestEffectBeaconStatus::inactive;
+        this->status_ = QuestEffectBeaconStatus::Active;
+        return true;
+        }
+        this->status_ = QuestEffectBeaconStatus::Inactive;
         return true;
+    }
 …
         if(this->getTimes() == 0) //!< Set the QuestEffectBeacon to inactive when the number of times it can be executed is reduced to 0.
+        {
             this->status_ = QuestEffectBeaconStatus::inactive;
+            this->status_ = QuestEffectBeaconStatus::Inactive;
+        }

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

-                      r3196
+                      r3280
     namespace QuestEffectBeaconStatus
+    {
         //! The status of the beacon, can be either active or inactive.
         enum Enum
+        enum Value
+        {
             inactive,
             active
+            Inactive,
+            Active
         };
+    }
 …
             */
             inline bool isActive(void)
             { return this->status_ == QuestEffectBeaconStatus::active; }
+            { return this->status_ == QuestEffectBeaconStatus::Active; }
             bool setActive(bool activate); //!< Set the status of the QuestEffectBeacon.
 …
             std::list<QuestEffect*> effects_; //!< The list of QuestEffects to be invoked on the executing player.
             int times_; //!< Number of times the beacon can be exectued.
             QuestEffectBeaconStatus::Enum status_; //!< The status of the QUestEffectBeacon, Can be eighter active or inactive.
+            QuestEffectBeaconStatus::Value status_; //!< The status of the QUestEffectBeacon, Can be eighter active or inactive.
             bool setTimes(const int & n); //!< Set the number of times the QuestEffectBeacon can be executed.

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

r3196	r3280
95	95
96	96	//! Find the player.
97		std::map<const PlayerInfo*, ~~questHintStatus::Enum~~>::const_iterator it = this->playerStatus_.find(player);
	97	std::map<const PlayerInfo*, QuestHintStatus::Value>::const_iterator it = this->playerStatus_.find(player);
98	98	if (it != this->playerStatus_.end()) //!< If the player is in the map.
99	99	{
…	…
101	101	}
102	102
103		return ~~questStatus::i~~nactive;
	103	return QuestStatus::Inactive;
104	104	}
105	105
…	…
118	118	if(!(this->isActive(player))) //!< If the hint is already active, activation is pointless.
119	119	{
120		this->playerStatus_[player] = ~~questHintStatus::a~~ctive;
	120	this->playerStatus_[player] = QuestHintStatus::Active;
121	121
122	122	this->getDescription()->sendAddHintNotification();

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

-                      r3196
+                      r3280
 namespace orxonox
+{
     namespace questHintStatus
+    namespace QuestHintStatus
+    {
         //! The state of the hint.
         enum Enum
+        enum Value
+        {
             inactive,
             active
+            Inactive,
+            Active
         };
+    }
 …
         private:
             Quest* quest_; //!< The Quest the QuestHint belongs to.
             std::map<const PlayerInfo*, questHintStatus::Enum> playerStatus_; //!< List of the states for each player, with the Player-pointer as key.
+            std::map<const PlayerInfo*, QuestHintStatus::Value> playerStatus_; //!< List of the states for each player, with the Player-pointer as key.
     };

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

r3196	r3280
51	51	RegisterObject(QuestListener);
52	52
53		this->mode_ = ~~questListenerMode::a~~ll;
	53	this->mode_ = QuestListenerMode::All;
54	54	this->quest_ = NULL;
55	55	}
…	…
132	132	if(mode == "all")
133	133	{
134		this->mode_ = ~~questListenerMode::a~~ll;
	134	this->mode_ = QuestListenerMode::All;
135	135	}
136	136	else if(mode == "start")
137	137	{
138		this->mode_ = ~~questListenerMode::s~~tart;
	138	this->mode_ = QuestListenerMode::Start;
139	139	}
140	140	else if(mode == "fail")
141	141	{
142		this->mode_ = ~~questListenerMode::f~~ail;
	142	this->mode_ = QuestListenerMode::Fail;
143	143	}
144	144	else if(mode == "complete")
145	145	{
146		this->mode_ = ~~questListenerMode::c~~omplete;
	146	this->mode_ = QuestListenerMode::Complete;
147	147	}
148	148	else
149	149	{
150	150	COUT(2) << "QuestListener with invalid mode '" << mode << "' created. Mode set to 'all'." << std::endl;
151		this->mode_ = ~~questListenerMode::a~~ll;
	151	this->mode_ = QuestListenerMode::All;
152	152	return false;
153	153	}
…	…
164	164	std::string QuestListener::getMode(void)
165	165	{
166		if(this->mode_ == ~~questListenerMode::a~~ll)
	166	if(this->mode_ == QuestListenerMode::All)
167	167	{
168	168	return "all";
169	169	}
170		else if(this->mode_ == ~~questListenerMode::s~~tart)
	170	else if(this->mode_ == QuestListenerMode::Start)
171	171	{
172	172	return "start";
173	173	}
174		else if(this->mode_ == ~~questListenerMode::f~~ail)
	174	else if(this->mode_ == QuestListenerMode::Fail)
175	175	{
176	176	return "fail";
177	177	}
178		else if(this->mode_ == ~~questListenerMode::c~~omplete)
	178	else if(this->mode_ == QuestListenerMode::Complete)
179	179	{
180	180	return "complete";

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

-                      r3196
+                      r3280
 namespace orxonox
+{
     namespace questListenerMode
+    namespace QuestListenerMode
+    {
         //! The mode of the QuestListener.
         enum Enum
+        enum Value
+        {
             all,
             start,
             fail,
             complete
+            All,
+            Start,
+            Fail,
+            Complete
         };
+    }
 …
     private:
         questListenerMode::Enum mode_; //!< The mode of the QuestListener.
+        QuestListenerMode::Value mode_; //!< The mode of the QuestListener.
         Quest* quest_; //!< A pointer to the Quest the QuestListener is reacting to.

code/trunk/src/orxonox/objects/weaponsystem/projectiles/LightningGunProjectile.cc

r3196	r3280
56	56	this->materialBase_ = material;
57	57
58		BillboardProjectile::setMaterial(material + ~~convertToString~~(this->textureIndex_));
	58	BillboardProjectile::setMaterial(material + multi_cast<std::string>(this->textureIndex_));
59	59	}
60	60

code/trunk/src/orxonox/objects/weaponsystem/projectiles/ParticleProjectile.cc

r3196	r3280
44	44	if (GameMode::showsGraphics())
45	45	{
46		this->particles_ = new ParticleInterface(this->getScene()->getSceneManager(), "Orxonox/shot3_small", LODParticle::normal);
	46	this->particles_ = new ParticleInterface(this->getScene()->getSceneManager(), "Orxonox/shot3_small", LODParticle::Normal);
47	47	this->attachOgreObject(this->particles_->getParticleSystem());
48	48	this->particles_->setKeepParticlesInLocalSpace(0);

code/trunk/src/orxonox/objects/worldentities/Backlight.cc

-                      r3196
+                      r3280
 #include "Backlight.h"
+#include <algorithm>
 #include <OgreRibbonTrail.h>
 #include <OgreSceneManager.h>
 …
     void Backlight::registerVariables()
+    {
         registerVariable(this->width_,         variableDirection::toclient, new NetworkCallback<Backlight>(this, &Backlight::update_width));
         registerVariable(this->lifetime_,      variableDirection::toclient, new NetworkCallback<Backlight>(this, &Backlight::update_lifetime));
         registerVariable(this->length_,        variableDirection::toclient, new NetworkCallback<Backlight>(this, &Backlight::update_length));
         registerVariable(this->maxelements_,   variableDirection::toclient, new NetworkCallback<Backlight>(this, &Backlight::update_maxelements));
         registerVariable(this->trailmaterial_, variableDirection::toclient, new NetworkCallback<Backlight>(this, &Backlight::update_trailmaterial));
+        registerVariable(this->width_,         VariableDirection::ToClient, new NetworkCallback<Backlight>(this, &Backlight::update_width));
+        registerVariable(this->lifetime_,      VariableDirection::ToClient, new NetworkCallback<Backlight>(this, &Backlight::update_lifetime));
+        registerVariable(this->length_,        VariableDirection::ToClient, new NetworkCallback<Backlight>(this, &Backlight::update_length));
+        registerVariable(this->maxelements_,   VariableDirection::ToClient, new NetworkCallback<Backlight>(this, &Backlight::update_maxelements));
+        registerVariable(this->trailmaterial_, VariableDirection::ToClient, new NetworkCallback<Backlight>(this, &Backlight::update_trailmaterial));
+    }
 …
     void Backlight::stopturnonoff()
+    {
         this->postprocessingtime_ = max(0.0f, this->lifetime_ - this->turnofftime_);
+        this->postprocessingtime_ = std::max(0.0f, this->lifetime_ - this->turnofftime_);
         FadingBillboard::stopturnonoff();

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

-                      r3196
+                      r3280
 */
         this->bStop_ = false;
         this->LOD_ = LODParticle::normal;
+        this->LOD_ = LODParticle::Normal;
 /*      this->stf_ = "setTimeFactor ";
 …
     void BigExplosion::registerVariables()
+    {
         registerVariable((int&)(this->LOD_), variableDirection::toclient, new NetworkCallback<BigExplosion>(this, &BigExplosion::LODchanged));
         registerVariable(this->bStop_,       variableDirection::toclient, new NetworkCallback<BigExplosion>(this, &BigExplosion::checkStop));
+        registerVariable((int&)(this->LOD_), VariableDirection::ToClient, new NetworkCallback<BigExplosion>(this, &BigExplosion::LODchanged));
+        registerVariable(this->bStop_,       VariableDirection::ToClient, new NetworkCallback<BigExplosion>(this, &BigExplosion::checkStop));
+    }

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

-                      r3196
+                      r3280
             void registerVariables();
             inline void setLOD(LODParticle::LOD level)
+            inline void setLOD(LODParticle::Value level)
                 { this->LOD_ = level; this->LODchanged(); }
             inline LODParticle::LOD getLOD() const
+            inline LODParticle::Value getLOD() const
                 { return this->LOD_; }
 …
             ParticleInterface*    explosionFire_;
             LODParticle::LOD      LOD_;
+            LODParticle::Value      LOD_;
             Timer<BigExplosion> destroyTimer_;
     };

code/trunk/src/orxonox/objects/worldentities/Billboard.cc

-                      r3196
+                      r3280
     void Billboard::registerVariables()
+    {
         registerVariable(this->material_, variableDirection::toclient, new NetworkCallback<Billboard>(this, &Billboard::changedMaterial));
         registerVariable(this->colour_,   variableDirection::toclient, new NetworkCallback<Billboard>(this, &Billboard::changedColour));
 //        registerVariable(this->rotation_, variableDirection::toclient, new NetworkCallback<Billboard>(this, &Billboard::changedRotation));
+        registerVariable(this->material_, VariableDirection::ToClient, new NetworkCallback<Billboard>(this, &Billboard::changedMaterial));
+        registerVariable(this->colour_,   VariableDirection::ToClient, new NetworkCallback<Billboard>(this, &Billboard::changedColour));
+//        registerVariable(this->rotation_, VariableDirection::ToClient, new NetworkCallback<Billboard>(this, &Billboard::changedRotation));
+    }

code/trunk/src/orxonox/objects/worldentities/BlinkingBillboard.cc

-                      r3196
+                      r3280
     void BlinkingBillboard::registerVariables()
+    {
 //        registerVariable(this->amplitude_, variableDirection::toclient);
 //        registerVariable(this->frequency_, variableDirection::toclient);
 //        registerVariable(this->phase_,     variableDirection::toclient);
+//        registerVariable(this->amplitude_, VariableDirection::ToClient);
+//        registerVariable(this->frequency_, VariableDirection::ToClient);
+//        registerVariable(this->phase_,     VariableDirection::ToClient);
+    }

code/trunk/src/orxonox/objects/worldentities/Camera.cc

-                      r3196
+                      r3280
 #include "Camera.h"
+#include <algorithm>
 #include <OgreCamera.h>
 #include <OgreSceneManager.h>
 …
 #include "util/Exception.h"
 #include "util/String.h"
+#include "util/StringUtils.h"
 #include "core/CoreIncludes.h"
 #include "core/ConfigValueIncludes.h"
 …
+        {
             // this stuff here may need some adjustments
             float coeff = min(1.0f, 15.0f * dt);
+            float coeff = std::min(1.0f, 15.0f * dt);
             Vector3 offset = this->getWorldPosition() - this->cameraNode_->_getDerivedPosition();

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

-                      r3196
+                      r3280
         this->setConfigValues();
         this->setPriority( priority::very_high );
+        this->setPriority( Priority::VeryHigh );
         this->registerVariables();
+    }
 …
+            {
                 this->client_overwrite_ = this->server_overwrite_;
                 this->setObjectMode(objectDirection::bidirectional);
+                this->setObjectMode(ObjectDirection::Bidirectional);
+            }
+        }
 …
         this->bHasLocalController_ = false;
         this->bHasHumanController_ = false;
         this->setObjectMode(objectDirection::toclient);
+        this->setObjectMode(ObjectDirection::ToClient);
         this->changedPlayer();
 …
     void ControllableEntity::registerVariables()
+    {
         registerVariable(this->cameraPositionTemplate_,  variableDirection::toclient);
         registerVariable(this->hudtemplate_,             variableDirection::toclient);
         registerVariable(this->server_position_,         variableDirection::toclient, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::processServerPosition));
         registerVariable(this->server_linear_velocity_,  variableDirection::toclient, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::processServerLinearVelocity));
         registerVariable(this->server_orientation_,      variableDirection::toclient, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::processServerOrientation));
         registerVariable(this->server_angular_velocity_, variableDirection::toclient, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::processServerAngularVelocity));
         registerVariable(this->server_overwrite_,        variableDirection::toclient, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::processOverwrite));
         registerVariable(this->client_overwrite_,        variableDirection::toserver);
         registerVariable(this->client_position_,         variableDirection::toserver, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::processClientPosition));
         registerVariable(this->client_linear_velocity_,  variableDirection::toserver, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::processClientLinearVelocity));
         registerVariable(this->client_orientation_,      variableDirection::toserver, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::processClientOrientation));
         registerVariable(this->client_angular_velocity_, variableDirection::toserver, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::processClientAngularVelocity));
+        registerVariable(this->cameraPositionTemplate_,  VariableDirection::ToClient);
+        registerVariable(this->hudtemplate_,             VariableDirection::ToClient);
+        registerVariable(this->server_position_,         VariableDirection::ToClient, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::processServerPosition));
+        registerVariable(this->server_linear_velocity_,  VariableDirection::ToClient, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::processServerLinearVelocity));
+        registerVariable(this->server_orientation_,      VariableDirection::ToClient, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::processServerOrientation));
+        registerVariable(this->server_angular_velocity_, VariableDirection::ToClient, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::processServerAngularVelocity));
+        registerVariable(this->server_overwrite_,        VariableDirection::ToClient, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::processOverwrite));
+        registerVariable(this->client_overwrite_,        VariableDirection::ToServer);
+        registerVariable(this->client_position_,         VariableDirection::ToServer, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::processClientPosition));
+        registerVariable(this->client_linear_velocity_,  VariableDirection::ToServer, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::processClientLinearVelocity));
+        registerVariable(this->client_orientation_,      VariableDirection::ToServer, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::processClientOrientation));
+        registerVariable(this->client_angular_velocity_, VariableDirection::ToServer, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::processClientAngularVelocity));
         registerVariable(this->playerID_,                variableDirection::toclient, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::networkcallback_changedplayerID));
+        registerVariable(this->playerID_,                VariableDirection::ToClient, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::networkcallback_changedplayerID));
+    }

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

-                      r3196
+                      r3280
         this->bStop_ = false;
         this->LOD_ = LODParticle::normal;
+        this->LOD_ = LODParticle::Normal;
         if ( GameMode::showsGraphics() )
 …
     void ExplosionChunk::registerVariables()
+    {
         registerVariable((int&)(this->LOD_), variableDirection::toclient, new NetworkCallback<ExplosionChunk>(this, &ExplosionChunk::LODchanged));
         registerVariable(this->bStop_,       variableDirection::toclient, new NetworkCallback<ExplosionChunk>(this, &ExplosionChunk::checkStop));
+        registerVariable((int&)(this->LOD_), VariableDirection::ToClient, new NetworkCallback<ExplosionChunk>(this, &ExplosionChunk::LODchanged));
+        registerVariable(this->bStop_,       VariableDirection::ToClient, new NetworkCallback<ExplosionChunk>(this, &ExplosionChunk::checkStop));
+    }

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

-                      r3196
+                      r3280
             void registerVariables();
             inline void setLOD(LODParticle::LOD level)
+            inline void setLOD(LODParticle::Value level)
                 { this->LOD_ = level; this->LODchanged(); }
             inline LODParticle::LOD getLOD() const
+            inline LODParticle::Value getLOD() const
                 { return this->LOD_; }
 …
             ParticleInterface*    fire_;
             ParticleInterface*    smoke_;
             LODParticle::LOD      LOD_;
+            LODParticle::Value      LOD_;
             Timer<ExplosionChunk> destroyTimer_;
     };

code/trunk/src/orxonox/objects/worldentities/FadingBillboard.cc

r3196	r3280
64	64	void FadingBillboard::registerVariables()
65	65	{
66		registerVariable(this->turnontime_, ~~variableDirection::toc~~lient);
67		registerVariable(this->turnofftime_, ~~variableDirection::toc~~lient);
	66	registerVariable(this->turnontime_, VariableDirection::ToClient);
	67	registerVariable(this->turnofftime_, VariableDirection::ToClient);
68	68	}
69	69

code/trunk/src/orxonox/objects/worldentities/Light.cc

-                      r3205
+                      r3280
 #include <boost/static_assert.hpp>
 #include "util/String.h"
+#include "util/StringUtils.h"
 #include "util/Exception.h"
 #include "core/CoreIncludes.h"
 …
     // Be sure we don't do bad conversions
     BOOST_STATIC_ASSERT((int)Ogre::Light::LT_POINT       == (int)Light::LT_POINT);
     BOOST_STATIC_ASSERT((int)Ogre::Light::LT_DIRECTIONAL == (int)Light::LT_DIRECTIONAL);
     BOOST_STATIC_ASSERT((int)Ogre::Light::LT_SPOTLIGHT   == (int)Light::LT_SPOTLIGHT);
+    BOOST_STATIC_ASSERT((int)Ogre::Light::LT_POINT       == (int)Light::Point);
+    BOOST_STATIC_ASSERT((int)Ogre::Light::LT_DIRECTIONAL == (int)Light::Directional);
+    BOOST_STATIC_ASSERT((int)Ogre::Light::LT_SPOTLIGHT   == (int)Light::Spotlight);
     Light::Light(BaseObject* creator) : StaticEntity(creator)
 …
         this->diffuse_ = ColourValue::White;
         this->specular_ = ColourValue::White;
         this->type_ = Light::LT_POINT;
+        this->type_ = Light::Point;
         this->attenuation_ = Vector4(100000, 1, 0, 0);
         this->spotlightRange_ = Vector3(40.0f, 30.0f, 1.0f);
 …
     void Light::registerVariables()
+    {
         registerVariable((int&)this->type_,     variableDirection::toclient, new NetworkCallback<Light>(this, &Light::updateType));
         registerVariable(this->diffuse_,        variableDirection::toclient, new NetworkCallback<Light>(this, &Light::updateDiffuseColour));
         registerVariable(this->specular_,       variableDirection::toclient, new NetworkCallback<Light>(this, &Light::updateSpecularColour));
         registerVariable(this->attenuation_,    variableDirection::toclient, new NetworkCallback<Light>(this, &Light::updateAttenuation));
         registerVariable(this->spotlightRange_, variableDirection::toclient, new NetworkCallback<Light>(this, &Light::updateSpotlightRange));
+        registerVariable((int&)this->type_,     VariableDirection::ToClient, new NetworkCallback<Light>(this, &Light::updateType));
+        registerVariable(this->diffuse_,        VariableDirection::ToClient, new NetworkCallback<Light>(this, &Light::updateDiffuseColour));
+        registerVariable(this->specular_,       VariableDirection::ToClient, new NetworkCallback<Light>(this, &Light::updateSpecularColour));
+        registerVariable(this->attenuation_,    VariableDirection::ToClient, new NetworkCallback<Light>(this, &Light::updateAttenuation));
+        registerVariable(this->spotlightRange_, VariableDirection::ToClient, new NetworkCallback<Light>(this, &Light::updateSpotlightRange));
+    }
 …
     void Light::updateAttenuation()
+    {
         if (this->light_ && this->type_ != Light::LT_DIRECTIONAL)
+        if (this->light_ && this->type_ != Light::Directional)
             this->light_->setAttenuation(this->attenuation_.x, this->attenuation_.y, this->attenuation_.z, this->attenuation_.w);
+    }
 …
     void Light::updateSpotlightRange()
+    {
         if (this->light_ && this->type_ == Light::LT_SPOTLIGHT)
+        if (this->light_ && this->type_ == Light::Spotlight)
             this->light_->setSpotlightRange(Degree(this->spotlightRange_.x), Degree(this->spotlightRange_.y), this->spotlightRange_.z);
+    }
 …
+    {
         if (type == "point")
             this->setType(Light::LT_POINT);
+            this->setType(Light::Point);
         else if (type == "directional")
             this->setType(Light::LT_DIRECTIONAL);
+            this->setType(Light::Directional);
         else if (type == "spotlight")
             this->setType(Light::LT_SPOTLIGHT);
+            this->setType(Light::Spotlight);
         else
             this->setType(Light::LT_POINT);
+            this->setType(Light::Point);
+    }
 …
         switch (this->type_)
+        {
             case Light::LT_DIRECTIONAL:
+            case Light::Directional:
                 return "directional";
             case Light::LT_SPOTLIGHT:
+            case Light::Spotlight:
                 return "spotlight";
             case Light::LT_POINT:
+            case Light::Point:
             default:
                 return "point";
 …
             this->light_->setType(static_cast<Ogre::Light::LightTypes>(this->type_));
             if (this->type_ != Light::LT_DIRECTIONAL)
+            if (this->type_ != Light::Directional)
                 this->updateAttenuation();
             if (this->type_ == Light::LT_SPOTLIGHT)
+            if (this->type_ == Light::Spotlight)
                 this->updateSpotlightRange();
+        }

code/trunk/src/orxonox/objects/worldentities/Light.h

-                      r3196
+                      r3280
+            {
                 /// Point light sources give off light equally in all directions, so require only position not direction
                 LT_POINT,
+                Point,
                 /// Directional lights simulate parallel light beams from a distant source, hence have direction but no position
                 LT_DIRECTIONAL,
+                Directional,
                 /// Spotlights simulate a cone of light from a source so require position and direction, plus extra values for falloff
                 LT_SPOTLIGHT
+                Spotlight
             };

code/trunk/src/orxonox/objects/worldentities/Model.cc

r3196	r3280
65	65	void Model::registerVariables()
66	66	{
67		registerVariable(this->meshSrc_, ~~variableDirection::toc~~lient, new NetworkCallback<Model>(this, &Model::changedMesh));
68		registerVariable(this->bCastShadows_, ~~variableDirection::toc~~lient, new NetworkCallback<Model>(this, &Model::changedShadows));
	67	registerVariable(this->meshSrc_, VariableDirection::ToClient, new NetworkCallback<Model>(this, &Model::changedMesh));
	68	registerVariable(this->bCastShadows_, VariableDirection::ToClient, new NetworkCallback<Model>(this, &Model::changedShadows));
69	69	}
70	70

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

-                      r3196
+                      r3280
         this->continuousResynchroTimer_ = 0;
         this->setPriority(priority::low);
+        this->setPriority(Priority::Low);
         this->registerVariables();
 …
     void MovableEntity::registerVariables()
+    {
         registerVariable(this->linearVelocity_,        variableDirection::toclient, new NetworkCallback<MovableEntity>(this, &MovableEntity::processLinearVelocity));
         registerVariable(this->angularVelocity_,       variableDirection::toclient, new NetworkCallback<MovableEntity>(this, &MovableEntity::processAngularVelocity));
+        registerVariable(this->linearVelocity_,        VariableDirection::ToClient, new NetworkCallback<MovableEntity>(this, &MovableEntity::processLinearVelocity));
+        registerVariable(this->angularVelocity_,       VariableDirection::ToClient, new NetworkCallback<MovableEntity>(this, &MovableEntity::processAngularVelocity));
         registerVariable(this->overwrite_position_,    variableDirection::toclient, new NetworkCallback<MovableEntity>(this, &MovableEntity::overwritePosition));
         registerVariable(this->overwrite_orientation_, variableDirection::toclient, new NetworkCallback<MovableEntity>(this, &MovableEntity::overwriteOrientation));
+        registerVariable(this->overwrite_position_,    VariableDirection::ToClient, new NetworkCallback<MovableEntity>(this, &MovableEntity::overwritePosition));
+        registerVariable(this->overwrite_orientation_, VariableDirection::ToClient, new NetworkCallback<MovableEntity>(this, &MovableEntity::overwriteOrientation));
+    }

code/trunk/src/orxonox/objects/worldentities/ParticleEmitter.cc

-                      r3196
+                      r3280
         this->particles_ = 0;
         this->LOD_ = LODParticle::normal;
+        this->LOD_ = LODParticle::Normal;
         this->registerVariables();
 …
         SUPER(ParticleEmitter, XMLPort, xmlelement, mode);
         XMLPortParam(ParticleEmitter, "lod",    setLODxml, getLODxml, xmlelement, mode).defaultValues(LODParticle::normal);
+        XMLPortParam(ParticleEmitter, "lod",    setLODxml, getLODxml, xmlelement, mode).defaultValues(LODParticle::Normal);
         XMLPortParam(ParticleEmitter, "source", setSource, getSource, xmlelement, mode);
+    }
 …
     void ParticleEmitter::registerVariables()
+    {
         registerVariable(this->source_, variableDirection::toclient, new NetworkCallback<ParticleEmitter>(this, &ParticleEmitter::sourceChanged));
         registerVariable((int&)(this->LOD_),    variableDirection::toclient, new NetworkCallback<ParticleEmitter>(this, &ParticleEmitter::LODchanged));
+        registerVariable(this->source_, VariableDirection::ToClient, new NetworkCallback<ParticleEmitter>(this, &ParticleEmitter::sourceChanged));
+        registerVariable((int&)(this->LOD_),    VariableDirection::ToClient, new NetworkCallback<ParticleEmitter>(this, &ParticleEmitter::LODchanged));
+    }

code/trunk/src/orxonox/objects/worldentities/ParticleEmitter.h

-                      r3196
+                      r3280
                 { return this->source_; }
             inline void setLOD(LODParticle::LOD level)
+            inline void setLOD(LODParticle::Value level)
                 { this->LOD_ = level; this->LODchanged(); }
             inline LODParticle::LOD getLOD() const
+            inline LODParticle::Value getLOD() const
                 { return this->LOD_; }
         protected:
             inline void setLODxml(unsigned int level)
                 { this->LOD_ = (LODParticle::LOD)level; this->LODchanged(); }
+                { this->LOD_ = (LODParticle::Value)level; this->LODchanged(); }
             inline unsigned int getLODxml() const
                 { return (unsigned int)this->LOD_; }
 …
             ParticleInterface* particles_;
             std::string        source_;
             LODParticle::LOD   LOD_;
+            LODParticle::Value   LOD_;
     };
+}

code/trunk/src/orxonox/objects/worldentities/Planet.cc

-                      r3196
+                      r3280
     void Planet::registerVariables()
+    {
         registerVariable(this->atmosphere_, variableDirection::toclient);
         registerVariable(this->meshSrc_, variableDirection::toclient, new NetworkCallback<Planet>(this, &Planet::changedMesh));
         registerVariable(this->bCastShadows_, variableDirection::toclient, new NetworkCallback<Planet>(this, &Planet::changedShadows));
         registerVariable(this->atmosphereSize, variableDirection::toclient);
         registerVariable(this->imageSize, variableDirection::toclient);
+        registerVariable(this->atmosphere_, VariableDirection::ToClient);
+        registerVariable(this->meshSrc_, VariableDirection::ToClient, new NetworkCallback<Planet>(this, &Planet::changedMesh));
+        registerVariable(this->bCastShadows_, VariableDirection::ToClient, new NetworkCallback<Planet>(this, &Planet::changedShadows));
+        registerVariable(this->atmosphereSize, VariableDirection::ToClient);
+        registerVariable(this->imageSize, VariableDirection::ToClient);
+    }

code/trunk/src/orxonox/objects/worldentities/PongBall.cc

r3196	r3280
72	72	registerVariable( this->relMercyOffset_ );
73	73	registerVariable( this->batID_[0] );
74		registerVariable( this->batID_[1], ~~variableDirection::toc~~lient, new NetworkCallback<PongBall>( this, &PongBall::applyBats) );
	74	registerVariable( this->batID_[1], VariableDirection::ToClient, new NetworkCallback<PongBall>( this, &PongBall::applyBats) );
75	75	}
76	76

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

-                      r3196
+                      r3280
         RegisterObject(StaticEntity);
         this->setPriority(priority::very_low);
+        this->setPriority(Priority::VeryLow);
         this->registerVariables();
 …
     void StaticEntity::registerVariables()
+    {
         registerVariable(this->getPosition(),    variableDirection::toclient, new NetworkCallback<StaticEntity>(this, &StaticEntity::positionChanged));
         registerVariable(this->getOrientation(), variableDirection::toclient, new NetworkCallback<StaticEntity>(this, &StaticEntity::orientationChanged));
+        registerVariable(this->getPosition(),    VariableDirection::ToClient, new NetworkCallback<StaticEntity>(this, &StaticEntity::positionChanged));
+        registerVariable(this->getOrientation(), VariableDirection::ToClient, new NetworkCallback<StaticEntity>(this, &StaticEntity::orientationChanged));
+    }

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

-                      r3196
+                      r3280
     void WorldEntity::registerVariables()
+    {
         registerVariable(this->mainStateName_,  variableDirection::toclient, new NetworkCallback<WorldEntity>(this, &WorldEntity::changedMainState));
         registerVariable(this->bActive_,        variableDirection::toclient, new NetworkCallback<WorldEntity>(this, &WorldEntity::changedActivity));
         registerVariable(this->bVisible_,       variableDirection::toclient, new NetworkCallback<WorldEntity>(this, &WorldEntity::changedVisibility));
         registerVariable(this->getScale3D(),    variableDirection::toclient, new NetworkCallback<WorldEntity>(this, &WorldEntity::scaleChanged));
+        registerVariable(this->mainStateName_,  VariableDirection::ToClient, new NetworkCallback<WorldEntity>(this, &WorldEntity::changedMainState));
+        registerVariable(this->bActive_,        VariableDirection::ToClient, new NetworkCallback<WorldEntity>(this, &WorldEntity::changedActivity));
+        registerVariable(this->bVisible_,       VariableDirection::ToClient, new NetworkCallback<WorldEntity>(this, &WorldEntity::changedVisibility));
+        registerVariable(this->getScale3D(),    VariableDirection::ToClient, new NetworkCallback<WorldEntity>(this, &WorldEntity::scaleChanged));
         // Physics stuff
         registerVariable(this->mass_,           variableDirection::toclient, new NetworkCallback<WorldEntity>(this, &WorldEntity::massChanged));
         registerVariable(this->restitution_,    variableDirection::toclient, new NetworkCallback<WorldEntity>(this, &WorldEntity::restitutionChanged));
         registerVariable(this->angularFactor_,  variableDirection::toclient, new NetworkCallback<WorldEntity>(this, &WorldEntity::angularFactorChanged));
         registerVariable(this->linearDamping_,  variableDirection::toclient, new NetworkCallback<WorldEntity>(this, &WorldEntity::linearDampingChanged));
         registerVariable(this->angularDamping_, variableDirection::toclient, new NetworkCallback<WorldEntity>(this, &WorldEntity::angularDampingChanged));
         registerVariable(this->friction_,       variableDirection::toclient, new NetworkCallback<WorldEntity>(this, &WorldEntity::frictionChanged));
+        registerVariable(this->mass_,           VariableDirection::ToClient, new NetworkCallback<WorldEntity>(this, &WorldEntity::massChanged));
+        registerVariable(this->restitution_,    VariableDirection::ToClient, new NetworkCallback<WorldEntity>(this, &WorldEntity::restitutionChanged));
+        registerVariable(this->angularFactor_,  VariableDirection::ToClient, new NetworkCallback<WorldEntity>(this, &WorldEntity::angularFactorChanged));
+        registerVariable(this->linearDamping_,  VariableDirection::ToClient, new NetworkCallback<WorldEntity>(this, &WorldEntity::linearDampingChanged));
+        registerVariable(this->angularDamping_, VariableDirection::ToClient, new NetworkCallback<WorldEntity>(this, &WorldEntity::angularDampingChanged));
+        registerVariable(this->friction_,       VariableDirection::ToClient, new NetworkCallback<WorldEntity>(this, &WorldEntity::frictionChanged));
         registerVariable(this->bCollisionCallbackActive_,
                                                 variableDirection::toclient, new NetworkCallback<WorldEntity>(this, &WorldEntity::collisionCallbackActivityChanged));
+                                                VariableDirection::ToClient, new NetworkCallback<WorldEntity>(this, &WorldEntity::collisionCallbackActivityChanged));
         registerVariable(this->bCollisionResponseActive_,
                                                 variableDirection::toclient, new NetworkCallback<WorldEntity>(this, &WorldEntity::collisionResponseActivityChanged));
+                                                VariableDirection::ToClient, new NetworkCallback<WorldEntity>(this, &WorldEntity::collisionResponseActivityChanged));
         registerVariable((int&)this->collisionTypeSynchronised_,
                                                 variableDirection::toclient, new NetworkCallback<WorldEntity>(this, &WorldEntity::collisionTypeChanged));
+                                                VariableDirection::ToClient, new NetworkCallback<WorldEntity>(this, &WorldEntity::collisionTypeChanged));
         registerVariable(this->bPhysicsActiveSynchronised_,
                                                 variableDirection::toclient, new NetworkCallback<WorldEntity>(this, &WorldEntity::physicsActivityChanged));
+                                                VariableDirection::ToClient, new NetworkCallback<WorldEntity>(this, &WorldEntity::physicsActivityChanged));
         // Attach to parent if necessary
         registerVariable(this->parentID_,       variableDirection::toclient, new NetworkCallback<WorldEntity>(this, &WorldEntity::networkcallback_parentChanged));
+        registerVariable(this->parentID_,       VariableDirection::ToClient, new NetworkCallback<WorldEntity>(this, &WorldEntity::networkcallback_parentChanged));
+    }

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

-                      r3214
+                      r3280
 #include "Pawn.h"
+#include <algorithm>
 #include "core/CoreIncludes.h"
 …
     void Pawn::registerVariables()
+    {
         registerVariable(this->bAlive_,        variableDirection::toclient);
         registerVariable(this->health_,        variableDirection::toclient);
         registerVariable(this->initialHealth_, variableDirection::toclient);
         registerVariable(this->bReload_,       variableDirection::toserver);
+        registerVariable(this->bAlive_,        VariableDirection::ToClient);
+        registerVariable(this->health_,        VariableDirection::ToClient);
+        registerVariable(this->initialHealth_, VariableDirection::ToClient);
+        registerVariable(this->bReload_,       VariableDirection::ToServer);
+    }
 …
     void Pawn::setHealth(float health)
+    {
         this->health_ = min(health, this->maxHealth_);
+        this->health_ = std::min(health, this->maxHealth_);
+    }

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

-                      r3196
+                      r3280
     void SpaceShip::registerVariables()
+    {
         registerVariable(this->primaryThrust_,  variableDirection::toclient);
         registerVariable(this->auxilaryThrust_, variableDirection::toclient);
         registerVariable(this->rotationThrust_, variableDirection::toclient);
+        registerVariable(this->primaryThrust_,  VariableDirection::ToClient);
+        registerVariable(this->auxilaryThrust_, VariableDirection::ToClient);
+        registerVariable(this->rotationThrust_, VariableDirection::ToClient);
+    }

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

r3196	r3280
93	93	void Spectator::registerVariables()
94	94	{
95		registerVariable(this->bGreetingFlareVisible_, ~~variableDirection::toc~~lient, new NetworkCallback<Spectator>(this, &Spectator::changedFlareVisibility));
96		registerVariable(this->bGreeting_, ~~variableDirection::tos~~erver, new NetworkCallback<Spectator>(this, &Spectator::changedGreeting));
	95	registerVariable(this->bGreetingFlareVisible_, VariableDirection::ToClient, new NetworkCallback<Spectator>(this, &Spectator::changedFlareVisibility));
	96	registerVariable(this->bGreeting_, VariableDirection::ToServer, new NetworkCallback<Spectator>(this, &Spectator::changedGreeting));
97	97	}
98	98
…	…
145	145	ControllableEntity::setPlayer(player);
146	146
147		// this->setObjectMode(~~objectDirection::toc~~lient);
	147	// this->setObjectMode(ObjectDirection::ToClient);
148	148	}
149	149

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

-                      r3196
+                      r3280
         RegisterObject(TeamBaseMatchBase);
         this->state_ = BaseState::uncontrolled;
+        this->state_ = BaseState::Uncontrolled;
         TeamBaseMatch* gametype = dynamic_cast<TeamBaseMatch*>(this->getGametype());
 …
         switch (this->state_)
+        {
             case BaseState::controlTeam1:
+            case BaseState::ControlTeam1:
                 colour = gametype->getTeamColour(0);
                 break;
             case BaseState::controlTeam2:
+            case BaseState::ControlTeam2:
                 colour = gametype->getTeamColour(1);
                 break;
             case BaseState::uncontrolled:
+            case BaseState::Uncontrolled:
             default:
                 colour = ColourValue(0.5, 0.5, 0.5, 1.0);

code/trunk/src/orxonox/objects/worldentities/pawns/TeamBaseMatchBase.h

-                      r3196
+                      r3280
     namespace BaseState
+    {
         enum Enum
+        enum Value
+        {
             uncontrolled,
             controlTeam1,
             controlTeam2,
+            Uncontrolled,
+            ControlTeam1,
+            ControlTeam2,
         };
+    }
 …
             // Set the state of a base to whatever the argument of the function is
             void setState(BaseState::Enum state)
+            void setState(BaseState::Value state)
+            {
                 this->state_ = state;
 …
             // Get the state of a base as a return value
             BaseState::Enum getState() const
+            BaseState::Value getState() const
+            {
                 return this->state_;
 …
             void changeTeamColour();
             BaseState::Enum state_;
+            BaseState::Value state_;
     };
+}

code/trunk/src/orxonox/objects/worldentities/triggers/DistanceTrigger.cc

r3196	r3280
141	141	}
142	142
143		bool DistanceTrigger::isTriggered(TriggerMode mode)
	143	bool DistanceTrigger::isTriggered(TriggerMode::Value mode)
144	144	{
145	145	if (Trigger::isTriggered(mode))

code/trunk/src/orxonox/objects/worldentities/triggers/DistanceTrigger.h

r3196	r3280
59	59
60	60	protected:
61		virtual bool isTriggered(TriggerMode mode);
	61	virtual bool isTriggered(TriggerMode::Value mode);
62	62	virtual void notifyMaskUpdate() {}
63	63

code/trunk/src/orxonox/objects/worldentities/triggers/EventTrigger.cc

r3196	r3280
54	54	}
55	55
56		bool EventTrigger::isTriggered(TriggerMode mode)
	56	bool EventTrigger::isTriggered(TriggerMode::Value mode)
57	57	{
58	58	if (Trigger::isTriggered(mode))

code/trunk/src/orxonox/objects/worldentities/triggers/EventTrigger.h

r3196	r3280
47	47
48	48	protected:
49		virtual bool isTriggered(TriggerMode mode);
	49	virtual bool isTriggered(TriggerMode::Value mode);
50	50
51	51	private:

code/trunk/src/orxonox/objects/worldentities/triggers/PlayerTrigger.h

r3196	r3280
70	70
71	71	protected:
72		virtual bool isTriggered(TriggerMode mode) = 0;
	72	virtual bool isTriggered(TriggerMode::Value mode) = 0;
73	73
74	74	/**

code/trunk/src/orxonox/objects/worldentities/triggers/Trigger.cc

-                      r3196
+                      r3280
     RegisterObject(Trigger);
     this->mode_ = TM_EventTriggerAND;
+    this->mode_ = TriggerMode::EventTriggerAND;
     this->bFirstTick_ = true;
 …
+  }
   bool Trigger::isTriggered(TriggerMode mode)
+  bool Trigger::isTriggered(TriggerMode::Value mode)
+  {
 //    if (this->bUpdating_)
 …
       switch (mode)
+      {
         case TM_EventTriggerAND:
+        case TriggerMode::EventTriggerAND:
           returnval = checkAnd();
           break;
         case TM_EventTriggerOR:
+        case TriggerMode::EventTriggerOR:
           returnval = checkOr();
           break;
         case TM_EventTriggerXOR:
+        case TriggerMode::EventTriggerXOR:
           returnval = checkXor();
           break;
 …
+  {
     if (modeName == "and")
       this->setMode(TM_EventTriggerAND);
+      this->setMode(TriggerMode::EventTriggerAND);
     else if (modeName == "or")
       this->setMode(TM_EventTriggerOR);
+      this->setMode(TriggerMode::EventTriggerOR);
     else if (modeName == "xor")
       this->setMode(TM_EventTriggerXOR);
+      this->setMode(TriggerMode::EventTriggerXOR);
+  }
   std::string Trigger::getModeString() const
+  {
     if (this->mode_ == TM_EventTriggerAND)
+    if (this->mode_ == TriggerMode::EventTriggerAND)
       return std::string("and");
     else if (this->mode_ == TM_EventTriggerOR)
+    else if (this->mode_ == TriggerMode::EventTriggerOR)
       return std::string("or");
     else if (this->mode_ == TM_EventTriggerXOR)
+    else if (this->mode_ == TriggerMode::EventTriggerXOR)
       return std::string("xor");
     else

code/trunk/src/orxonox/objects/worldentities/triggers/Trigger.h

-                      r3196
+                      r3280
 namespace orxonox
+{
   enum TriggerMode
+  namespace TriggerMode
+  {
+    TM_EventTriggerAND,
+    TM_EventTriggerOR,
+    TM_EventTriggerXOR,
+  };
+    enum Value
+    {
+      EventTriggerAND,
+      EventTriggerOR,
+      EventTriggerXOR,
+    };
+  }
   class _OrxonoxExport Trigger : public StaticEntity, public Tickable
 …
       void setMode(const std::string& modeName);
       inline void setMode(TriggerMode mode)
+      inline void setMode(TriggerMode::Value mode)
         { this->mode_ = mode; }
       inline TriggerMode getMode() const
+      inline TriggerMode::Value getMode() const
         { return mode_; }
 …
     protected:
       inline bool isTriggered() { return this->isTriggered(this->mode_); }
       virtual bool isTriggered(TriggerMode mode);
+      virtual bool isTriggered(TriggerMode::Value mode);
       virtual void triggered(bool bIsTriggered);
 …
       bool bFirstTick_;
       TriggerMode mode_;
+      TriggerMode::Value mode_;
       bool bInvertMode_;
       bool bSwitch_;

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

-                      r3196
+                      r3280
 #include "util/Convert.h"
 #include "util/Exception.h"
 #include "util/String.h"
+#include "util/StringUtils.h"
 #include "core/GameMode.h"
 #include "core/CoreIncludes.h"
 …
         // create the Ogre::Overlay
         overlay_ = Ogre::OverlayManager::getSingleton().create("OrxonoxOverlay_overlay_"
             + convertToString(hudOverlayCounter_s++));
+            + multi_cast<std::string>(hudOverlayCounter_s++));
         // create background panel (can be used to show any picture)
         this->background_ = static_cast<Ogre::PanelOverlayElement*>(
             Ogre::OverlayManager::getSingleton().createOverlayElement("Panel",
             "OrxonoxOverlay_background_" + convertToString(hudOverlayCounter_s++)));
+            "OrxonoxOverlay_background_" + multi_cast<std::string>(hudOverlayCounter_s++)));
         this->overlay_->add2D(this->background_);

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

r3196	r3280
34	34	#include <boost/static_assert.hpp>
35	35
36		#include "util/String.h"
	36	#include "util/StringUtils.h"
37	37	#include "core/CoreIncludes.h"
38	38	#include "core/XMLPort.h"

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

-                      r3196
+                      r3280
 #include "InGameConsole.h"
+#include <algorithm>
 #include <string>
 #include <OgreOverlay.h>
 …
         for (int i = 0; i < LINES; i++)
+        {
             this->consoleOverlayTextAreas_[i] = static_cast<Ogre::TextAreaOverlayElement*>(ovMan->createOverlayElement("TextArea", "InGameConsoleTextArea" + convertToString(i)));
+            this->consoleOverlayTextAreas_[i] = static_cast<Ogre::TextAreaOverlayElement*>(ovMan->createOverlayElement("TextArea", "InGameConsoleTextArea" + multi_cast<std::string>(i)));
             this->consoleOverlayTextAreas_[i]->setMetricsMode(Ogre::GMM_PIXELS);
             this->consoleOverlayTextAreas_[i]->setFontName("MonofurConsole");
 …
         if (LINES > 0)
             this->maxCharsPerLine_ = max((unsigned int)10, (unsigned int) ((float)this->desiredTextWidth_ / CHAR_WIDTH));
+            this->maxCharsPerLine_ = std::max((unsigned int)10, (unsigned int) ((float)this->desiredTextWidth_ / CHAR_WIDTH));
         else
             this->maxCharsPerLine_ = 10;

code/trunk/src/orxonox/overlays/hud/GametypeStatus.cc

r3196	r3280
70	70	{
71	71	if (gtinfo->isStartCountdownRunning())
72		this->setCaption(~~convertToString~~((int)ceil(gtinfo->getStartCountdown())));
	72	this->setCaption(multi_cast<std::string>((int)ceil(gtinfo->getStartCountdown())));
73	73	else if (ce->isA(Class(Spectator)))
74	74	this->setCaption("Press [Fire] to respawn");

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

-                      r3196
+                      r3280
 #include "util/Convert.h"
 #include "util/String.h"
+#include "util/StringUtils.h"
 #include "core/CoreIncludes.h"
 #include "core/XMLPort.h"
 …
         // create new material
         std::string materialname = "barmaterial" + getConvertedValue<unsigned int, std::string>(materialcount_s++);
+        std::string materialname = "barmaterial" + multi_cast<std::string>(materialcount_s++);
         Ogre::MaterialPtr material = (Ogre::MaterialPtr)Ogre::MaterialManager::getSingleton().create(materialname, "General");
         material->getTechnique(0)->getPass(0)->setSceneBlending(Ogre::SBT_TRANSPARENT_ALPHA);

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

r3196	r3280
83	83	{
84	84	this->setValue(this->owner_->getHealth() / this->owner_->getInitialHealth());
85		this->textoverlay_->setCaption(~~convertToString~~((int)this->owner_->getHealth()));
	85	this->textoverlay_->setCaption(multi_cast<std::string>((int)this->owner_->getHealth()));
86	86	}
87	87

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

-                      r3196
+                      r3280
 #include "util/Math.h"
 #include "util/String.h"
+#include "util/StringUtils.h"
 #include "util/Convert.h"
 #include "core/CoreIncludes.h"
 …
         // set text
         int dist = (int) getDist2Focus();
         navText_->setCaption(convertToString(dist));
         float textLength = convertToString(dist).size() * navText_->getCharHeight() * 0.3;
+        navText_->setCaption(multi_cast<std::string>(dist));
+        float textLength = multi_cast<std::string>(dist).size() * navText_->getCharHeight() * 0.3;
 /*

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

r3196	r3280
34	34
35	35	#include "util/Math.h"
36		#include "util/String.h"
	36	#include "util/StringUtils.h"
37	37	#include "core/CoreIncludes.h"
38	38	#include "core/XMLPort.h"

code/trunk/src/orxonox/overlays/hud/HUDTimer.cc

r3196	r3280
59	59	if (gametype->getTimerIsActive())
60	60	{
61		this->setCaption(~~convertToString~~((int)gametype->getTime() + 1));
	61	this->setCaption(multi_cast<std::string>((int)gametype->getTime() + 1));
62	62	}
63	63	}

code/trunk/src/orxonox/overlays/hud/PongScore.cc

r3196	r3280
83	83	{
84	84	name1 = player1->getName();
85		score1 = ~~convertToString~~(this->owner_->getScore(player1));
	85	score1 = multi_cast<std::string>(this->owner_->getScore(player1));
86	86	}
87	87
…	…
89	89	{
90	90	name2 = player2->getName();
91		score2 = ~~convertToString~~(this->owner_->getScore(player2));
	91	score2 = multi_cast<std::string>(this->owner_->getScore(player2));
92	92	}
93	93

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

-                      r3196
+                      r3280
         if (this->owner_)
+        {
             std::string bases1 = "(" + convertToString(this->owner_->getTeamBases(0)) + ")";
             std::string bases2 = "(" + convertToString(this->owner_->getTeamBases(1)) + ")";
+            std::string bases1 = "(" + multi_cast<std::string>(this->owner_->getTeamBases(0)) + ")";
+            std::string bases2 = "(" + multi_cast<std::string>(this->owner_->getTeamBases(1)) + ")";
             std::string score1 = convertToString(this->owner_->getTeamPoints(0));
             std::string score2 = convertToString(this->owner_->getTeamPoints(1));
+            std::string score1 = multi_cast<std::string>(this->owner_->getTeamPoints(0));
+            std::string score2 = multi_cast<std::string>(this->owner_->getTeamPoints(1));
             std::string output1;

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

r3196	r3280
99	99	// while (textColumns_.size() < numberOfColumns)
100	100	// {
101		// Ogre::TextAreaOverlayElement* tempTextArea = static_cast<Ogre::TextAreaOverlayElement*>(ovMan->createOverlayElement("TextArea", "StatsLineTextArea" + getName() + ~~convertToString(lineIndex) + convertToString~~(colIndex)));
	101	// Ogre::TextAreaOverlayElement* tempTextArea = static_cast<Ogre::TextAreaOverlayElement*>(ovMan->createOverlayElement("TextArea", "StatsLineTextArea" + getName() + multi_cast<std::string>(lineIndex) + multi_cast<std::string>(colIndex)));
102	102	// textColumns_.push_back(tempTextArea);
103	103	// this->background_->addChild(tempTextArea);

code/trunk/src/orxonox/overlays/stats/Stats.cc

r3196	r3280
33	33	#include <OgreBorderPanelOverlayElement.h>
34	34
35		#include "util/String.h"
	35	#include "util/StringUtils.h"
36	36	#include "core/CoreIncludes.h"
37	37	#include "core/ConfigValueIncludes.h"

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

-                      r3196
+                      r3280
+{
     SoundManager* SoundManager::singletonRef_s = NULL;
-    ALCdevice* SoundManager::device_s = NULL;
     /**
 …
         singletonRef_s = this;
+        this->device_ = NULL;
         this->soundavailable_ = true;
         if(!alutInitWithoutContext(NULL,NULL))
 …
         else
+        {
+            if(SoundManager::device_s == NULL)
+            {
+                COUT(3) << "Sound: OpenAL: Open sound device..." << std::endl;
+                SoundManager::device_s = alcOpenDevice(NULL);
+            }
+            assert(this->device_ == NULL);
+            COUT(3) << "Sound: OpenAL: Open sound device..." << std::endl;
+            this->device_ = alcOpenDevice(NULL);
             if(SoundManager::device_s == NULL)
+            if(this->device_ == NULL)
+            {
                 COUT(2) << "Sound: OpenAL: Could not open sound device" << std::endl;
 …
+            {
                 COUT(3) << "Sound: OpenAL: Sound device opened" << std::endl;
                 this->context_ = alcCreateContext(SoundManager::device_s, NULL);
+                this->context_ = alcCreateContext(this->device_, NULL);
                 if(this->context_ == NULL)
+                {
 …
         alcDestroyContext(this->context_);
         alcCloseDevice(SoundManager::device_s);
+        alcCloseDevice(this->device_);
         alutExit();
+    }

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

r3196	r3280
55	55
56	56	private:
57		~~static ALCdevice* device_s~~;
	57	ALCdevice* device_;
58	58	ALCcontext* context_;
59	59	std::list<SoundBase*> soundlist_;

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

-                      r3196
+                      r3280
 #include "util/Convert.h"
 #include "util/Math.h"
 #include "util/String.h"
+#include "util/StringUtils.h"
 #include "core/GameMode.h"
 …
             if (GameMode::showsGraphics())
+            {
                 this->billboardSet_ = scenemanager->createBillboardSet("Billboard" + convertToString(BillboardSet::billboardSetCounter_s++), count);
+                this->billboardSet_ = scenemanager->createBillboardSet("Billboard" + multi_cast<std::string>(BillboardSet::billboardSetCounter_s++), count);
                 this->billboardSet_->createBillboard(position);
                 this->billboardSet_->setMaterialName(file);
 …
             if (GameMode::showsGraphics())
+            {
                 this->billboardSet_ = scenemanager->createBillboardSet("Billboard" + convertToString(BillboardSet::billboardSetCounter_s++), count);
+                this->billboardSet_ = scenemanager->createBillboardSet("Billboard" + multi_cast<std::string>(BillboardSet::billboardSetCounter_s++), count);
                 this->billboardSet_->createBillboard(position, colour);
                 this->billboardSet_->setMaterialName(file);

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

-                      r3196
+                      r3280
 #include "util/Convert.h"
 #include "util/String.h"
+#include "util/StringUtils.h"
 #include "core/GameMode.h"
 …
             try
+            {
                 this->entity_ = this->scenemanager_->createEntity("Mesh" + convertToString(Mesh::meshCounter_s++), meshsource);
+                this->entity_ = this->scenemanager_->createEntity("Mesh" + multi_cast<std::string>(Mesh::meshCounter_s++), meshsource);
                 this->entity_->setCastShadows(this->bCastShadows_);

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

r3196	r3280
51	51	ParticleInterface* ParticleInterface::currentParticleInterface_s = 0;
52	52
53		ParticleInterface::ParticleInterface(Ogre::SceneManager* scenemanager, const std::string& templateName, LODParticle::~~LOD~~ detaillevel)
	53	ParticleInterface::ParticleInterface(Ogre::SceneManager* scenemanager, const std::string& templateName, LODParticle::Value detaillevel)
54	54	{
55	55	RegisterObject(ParticleInterface);
…	…
69	69	try
70	70	{
71		this->particleSystem_ = this->scenemanager_->createParticleSystem("particles" + ~~getConvertedValue<unsigned int,~~ std::string>(ParticleInterface::counter_s++), templateName);
	71	this->particleSystem_ = this->scenemanager_->createParticleSystem("particles" + multi_cast<std::string>(ParticleInterface::counter_s++), templateName);
72	72	this->setSpeedFactor(1.0f);
73	73	}

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

r3196	r3280
45	45	{
46	46	public:
47		ParticleInterface(Ogre::SceneManager* scenemanager, const std::string& templateName, LODParticle::~~LOD~~ detaillevel);
	47	ParticleInterface(Ogre::SceneManager* scenemanager, const std::string& templateName, LODParticle::Value detaillevel);
48	48	virtual ~ParticleInterface();
49	49

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

r3196	r3280
72	72	if (it == colourMap.end())
73	73	{
74		std::string materialName = textureName + "_Material_" + ~~convertToString~~(materialCount_s++);
	74	std::string materialName = textureName + "_Material_" + multi_cast<std::string>(materialCount_s++);
75	75	Ogre::MaterialPtr material = (Ogre::MaterialPtr)Ogre::MaterialManager::getSingleton().create(materialName, "General");
76	76	material->getTechnique(0)->getPass(0)->setSceneBlending(Ogre::SBT_TRANSPARENT_ALPHA);

code/trunk/src/util/CMakeLists.txt

r3196	r3280
29	29	SignalHandler.cc
30	30	Sleep.cc
31		String.cc
	31	StringUtils.cc
32	32	SubString.cc
33	33	)

code/trunk/src/util/Convert.h

-                      r3234
+                      r3280
 #include "Debug.h"
 #include "String.h"
+#include "StringUtils.h"
 #include "TemplateUtils.h"
 …
+    }
-    // convert to string Shortcut
-    template <class FromType>
-    FORCEINLINE std::string convertToString(FromType value)
+    {
-        return getConvertedValue<FromType, std::string>(value);
+    }
-    // convert from string Shortcut
-    template <class ToType>
-    FORCEINLINE ToType convertFromString(std::string str)
+    {
-        return getConvertedValue<std::string, ToType>(str);
+    }
     ////////////////////////////////
     // Special string conversions //

code/trunk/src/util/Exception.cc

-                      r3196
+                      r3280
             std::ostringstream fullDesc;
             fullDesc << this->getTypeName() << "_EXCEPTION";
+            fullDesc << this->getTypeName() << "Exception";
             if (this->filename_ != "")
 …
         return fullDescription_;
+    }
+    //! Returns the error description
+    const char* Exception::what() const throw()
+    {
+        return getDescription().c_str();
+    }
+}

code/trunk/src/util/Exception.h

-                      r3196
+                      r3280
         //! Needed for compatibility with std::exception
         virtual ~Exception() throw() { }
+        const char* what() const throw();
         //! Returns a full description with type, line, file and function
 …
         //! Returns the filename in which the exception occurred.
         virtual const std::string& getFilename()        const { return this->filename_; }
-        //! Returns a full description of the error.
-        const char* what() const throw() { return getFullDescription().c_str(); }
     protected:
 …
     Exception description as string
 */
 #define ThrowException(type, description, ...) \
+#define ThrowException(type, description) \
     throw orxonox::exceptionThrowerHelper(type##Exception(static_cast<std::ostringstream&>(std::ostringstream().flush() << description).str(), __LINE__, __FILE__, __FUNCTIONNAME__))

code/trunk/src/util/Math.h

-                      r3214
+                      r3280
+    {
         return (x >= 0) ? 1 : -1;
+    }
-    /**
-        @brief Returns the smaller of two values.
-    */
-    template <typename T>
-    inline T min(T a, T b)
+    {
-        return (a <= b) ? a : b;
+    }
-    /**
-        @brief Returns the greater of two values.
-    */
-    template <typename T>
-    inline T max(T a, T b)
+    {
-        return (a >= b) ? a : b;
+    }

code/trunk/src/util/MultiType.cc

-                      r3196
+                      r3280
         @param type The type
     */
     bool MultiType::convert(MT_Type type)
+    bool MultiType::convert(MT_Type::Value type)
+    {
         switch (type)
+        {
             case MT_null:
+            case MT_Type::Null:
                 this->reset(); return true;
             case MT_char:
+            case MT_Type::Char:
                 return this->convert<char>(); break;
             case MT_uchar:
+            case MT_Type::UnsignedChar:
                 return this->convert<unsigned char>(); break;
             case MT_short:
+            case MT_Type::Short:
                 return this->convert<short>(); break;
             case MT_ushort:
+            case MT_Type::UnsignedShort:
                 return this->convert<unsigned short>(); break;
             case MT_int:
+            case MT_Type::Int:
                 return this->convert<int>(); break;
             case MT_uint:
+            case MT_Type::UnsignedInt:
                 return this->convert<unsigned int>(); break;
             case MT_long:
+            case MT_Type::Long:
                 return this->convert<long>(); break;
             case MT_ulong:
+            case MT_Type::UnsignedLong:
                 return this->convert<unsigned long>(); break;
             case MT_longlong:
+            case MT_Type::LongLong:
                 return this->convert<long long>(); break;
             case MT_ulonglong:
+            case MT_Type::UnsignedLongLong:
                 return this->convert<unsigned long long>(); break;
             case MT_float:
+            case MT_Type::Float:
                 return this->convert<float>(); break;
             case MT_double:
+            case MT_Type::Double:
                 return this->convert<double>(); break;
             case MT_longdouble:
+            case MT_Type::LongDouble:
                 return this->convert<long double>(); break;
             case MT_bool:
+            case MT_Type::Bool:
                 return this->convert<bool>(); break;
             case MT_void:
+            case MT_Type::VoidPointer:
                 return this->convert<void*>(); break;
             case MT_string:
+            case MT_Type::String:
                 return this->convert<std::string>(); break;
             case MT_vector2:
+            case MT_Type::Vector2:
                 return this->convert<orxonox::Vector2>(); break;
             case MT_vector3:
+            case MT_Type::Vector3:
                 return this->convert<orxonox::Vector3>(); break;
             case MT_vector4:
+            case MT_Type::Vector4:
                 return this->convert<orxonox::Vector4>(); break;
             case MT_colourvalue:
+            case MT_Type::ColourValue:
                 return this->convert<orxonox::ColourValue>(); break;
             case MT_quaternion:
+            case MT_Type::Quaternion:
                 return this->convert<orxonox::Quaternion>(); break;
             case MT_radian:
+            case MT_Type::Radian:
                 return this->convert<orxonox::Radian>(); break;
             case MT_degree:
+            case MT_Type::Degree:
                 return this->convert<orxonox::Degree>(); break;
             default:
 …
     std::string MultiType::getTypename() const
+    {
         MT_Type type = (this->value_) ? this->value_->type_ : MT_null;
+        MT_Type::Value type = (this->value_) ? this->value_->type_ : MT_Type::Null;
         switch (type)
+        {
             case MT_char:
+            case MT_Type::Char:
                 return "char"; break;
             case MT_uchar:
+            case MT_Type::UnsignedChar:
                 return "unsigned char"; break;
             case MT_short:
+            case MT_Type::Short:
                 return "short"; break;
             case MT_ushort:
+            case MT_Type::UnsignedShort:
                 return "unsigned short"; break;
             case MT_int:
+            case MT_Type::Int:
                 return "int"; break;
             case MT_uint:
+            case MT_Type::UnsignedInt:
                 return "unsigned int"; break;
             case MT_long:
+            case MT_Type::Long:
                 return "long"; break;
             case MT_ulong:
+            case MT_Type::UnsignedLong:
                 return "unsigned long"; break;
             case MT_longlong:
+            case MT_Type::LongLong:
                 return "long long"; break;
             case MT_ulonglong:
+            case MT_Type::UnsignedLongLong:
                 return "unsigned long long"; break;
             case MT_float:
+            case MT_Type::Float:
                 return "float"; break;
             case MT_double:
+            case MT_Type::Double:
                 return "double"; break;
             case MT_longdouble:
+            case MT_Type::LongDouble:
                 return "long double"; break;
             case MT_bool:
+            case MT_Type::Bool:
                 return "bool"; break;
             case MT_void:
+            case MT_Type::VoidPointer:
                 return "void*"; break;
             case MT_string:
+            case MT_Type::String:
                 return "std::string"; break;
             case MT_vector2:
+            case MT_Type::Vector2:
                 return "orxonox::Vector2"; break;
             case MT_vector3:
+            case MT_Type::Vector3:
                 return "orxonox::Vector3"; break;
             case MT_vector4:
+            case MT_Type::Vector4:
                 return "orxonox::Vector4"; break;
             case MT_colourvalue:
+            case MT_Type::ColourValue:
                 return "orxonox::ColourValue"; break;
             case MT_quaternion:
+            case MT_Type::Quaternion:
                 return "orxonox::Quaternion"; break;
             case MT_radian:
+            case MT_Type::Radian:
                 return "orxonox::Radian"; break;
             case MT_degree:
+            case MT_Type::Degree:
                 return "orxonox::Degree"; break;
             default:
 …
+    }
     MultiType::operator char()                 const { return (this->value_) ? ((this->value_->type_ == MT_char       ) ? (static_cast<MT_Value<char>                *>(this->value_))->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
     MultiType::operator unsigned char()        const { return (this->value_) ? ((this->value_->type_ == MT_uchar      ) ? (static_cast<MT_Value<unsigned char>       *>(this->value_))->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
     MultiType::operator short()                const { return (this->value_) ? ((this->value_->type_ == MT_short      ) ? (static_cast<MT_Value<short>               *>(this->value_))->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
     MultiType::operator unsigned short()       const { return (this->value_) ? ((this->value_->type_ == MT_ushort     ) ? (static_cast<MT_Value<unsigned short>      *>(this->value_))->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
     MultiType::operator int()                  const { return (this->value_) ? ((this->value_->type_ == MT_int        ) ? (static_cast<MT_Value<int>                 *>(this->value_))->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
     MultiType::operator unsigned int()         const { return (this->value_) ? ((this->value_->type_ == MT_uint       ) ? (static_cast<MT_Value<unsigned int>        *>(this->value_))->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
     MultiType::operator long()                 const { return (this->value_) ? ((this->value_->type_ == MT_long       ) ? (static_cast<MT_Value<long>                *>(this->value_))->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
     MultiType::operator unsigned long()        const { return (this->value_) ? ((this->value_->type_ == MT_ulong      ) ? (static_cast<MT_Value<unsigned long>       *>(this->value_))->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
     MultiType::operator long long()            const { return (this->value_) ? ((this->value_->type_ == MT_longlong   ) ? (static_cast<MT_Value<long long>           *>(this->value_))->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
     MultiType::operator unsigned long long()   const { return (this->value_) ? ((this->value_->type_ == MT_ulonglong  ) ? (static_cast<MT_Value<unsigned long long>  *>(this->value_))->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
     MultiType::operator float()                const { return (this->value_) ? ((this->value_->type_ == MT_float      ) ? (static_cast<MT_Value<float>               *>(this->value_))->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
     MultiType::operator double()               const { return (this->value_) ? ((this->value_->type_ == MT_double     ) ? (static_cast<MT_Value<double>              *>(this->value_))->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
     MultiType::operator long double()          const { return (this->value_) ? ((this->value_->type_ == MT_longdouble ) ? (static_cast<MT_Value<long double>         *>(this->value_))->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
     MultiType::operator bool()                 const { return (this->value_) ? ((this->value_->type_ == MT_bool       ) ? (static_cast<MT_Value<bool>                *>(this->value_))->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
     MultiType::operator void*()                const { return (this->value_) ? ((this->value_->type_ == MT_void       ) ? (static_cast<MT_Value<void*>               *>(this->value_))->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
     MultiType::operator std::string()          const { return (this->value_) ? ((this->value_->type_ == MT_string     ) ? (static_cast<MT_Value<std::string>         *>(this->value_))->value_ : (*this->value_)) : NilValue<std::string>();          } /** @brief Returns the current value, converted to the requested type. */
     MultiType::operator orxonox::Vector2()     const { return (this->value_) ? ((this->value_->type_ == MT_vector2    ) ? (static_cast<MT_Value<orxonox::Vector2>    *>(this->value_))->value_ : (*this->value_)) : NilValue<orxonox::Vector2>();     } /** @brief Returns the current value, converted to the requested type. */
     MultiType::operator orxonox::Vector3()     const { return (this->value_) ? ((this->value_->type_ == MT_vector3    ) ? (static_cast<MT_Value<orxonox::Vector3>    *>(this->value_))->value_ : (*this->value_)) : NilValue<orxonox::Vector3>();     } /** @brief Returns the current value, converted to the requested type. */
     MultiType::operator orxonox::Vector4()     const { return (this->value_) ? ((this->value_->type_ == MT_vector4    ) ? (static_cast<MT_Value<orxonox::Vector4>    *>(this->value_))->value_ : (*this->value_)) : NilValue<orxonox::Vector4>();     } /** @brief Returns the current value, converted to the requested type. */
     MultiType::operator orxonox::ColourValue() const { return (this->value_) ? ((this->value_->type_ == MT_colourvalue) ? (static_cast<MT_Value<orxonox::ColourValue>*>(this->value_))->value_ : (*this->value_)) : NilValue<orxonox::ColourValue>(); } /** @brief Returns the current value, converted to the requested type. */
     MultiType::operator orxonox::Quaternion()  const { return (this->value_) ? ((this->value_->type_ == MT_quaternion ) ? (static_cast<MT_Value<orxonox::Quaternion> *>(this->value_))->value_ : (*this->value_)) : NilValue<orxonox::Quaternion>();  } /** @brief Returns the current value, converted to the requested type. */
     MultiType::operator orxonox::Radian()      const { return (this->value_) ? ((this->value_->type_ == MT_radian     ) ? (static_cast<MT_Value<orxonox::Radian>     *>(this->value_))->value_ : (*this->value_)) : NilValue<orxonox::Radian>();      } /** @brief Returns the current value, converted to the requested type. */
     MultiType::operator orxonox::Degree()      const { return (this->value_) ? ((this->value_->type_ == MT_degree     ) ? (static_cast<MT_Value<orxonox::Degree>     *>(this->value_))->value_ : (*this->value_)) : NilValue<orxonox::Degree>();      } /** @brief Returns the current value, converted to the requested type. */
     template <> void MultiType::createNewValueContainer(const char& value)                 { this->value_ = new MT_Value<char>                (value, MT_char       ); } /** @brief Creates a new value container for the given type. */
     template <> void MultiType::createNewValueContainer(const unsigned char& value)        { this->value_ = new MT_Value<unsigned char>       (value, MT_uchar      ); } /** @brief Creates a new value container for the given type. */
     template <> void MultiType::createNewValueContainer(const short& value)                { this->value_ = new MT_Value<short>               (value, MT_short      ); } /** @brief Creates a new value container for the given type. */
     template <> void MultiType::createNewValueContainer(const unsigned short& value)       { this->value_ = new MT_Value<unsigned short>      (value, MT_ushort     ); } /** @brief Creates a new value container for the given type. */
     template <> void MultiType::createNewValueContainer(const int& value)                  { this->value_ = new MT_Value<int>                 (value, MT_int        ); } /** @brief Creates a new value container for the given type. */
     template <> void MultiType::createNewValueContainer(const unsigned int& value)         { this->value_ = new MT_Value<unsigned int>        (value, MT_uint       ); } /** @brief Creates a new value container for the given type. */
     template <> void MultiType::createNewValueContainer(const long& value)                 { this->value_ = new MT_Value<long>                (value, MT_long       ); } /** @brief Creates a new value container for the given type. */
     template <> void MultiType::createNewValueContainer(const unsigned long& value)        { this->value_ = new MT_Value<unsigned long>       (value, MT_ulong      ); } /** @brief Creates a new value container for the given type. */
     template <> void MultiType::createNewValueContainer(const long long& value)            { this->value_ = new MT_Value<long long>           (value, MT_longlong   ); } /** @brief Creates a new value container for the given type. */
     template <> void MultiType::createNewValueContainer(const unsigned long long& value)   { this->value_ = new MT_Value<unsigned long long>  (value, MT_ulonglong  ); } /** @brief Creates a new value container for the given type. */
     template <> void MultiType::createNewValueContainer(const float& value)                { this->value_ = new MT_Value<float>               (value, MT_float      ); } /** @brief Creates a new value container for the given type. */
     template <> void MultiType::createNewValueContainer(const double& value)               { this->value_ = new MT_Value<double>              (value, MT_double     ); } /** @brief Creates a new value container for the given type. */
     template <> void MultiType::createNewValueContainer(const long double& value)          { this->value_ = new MT_Value<long double>         (value, MT_longdouble ); } /** @brief Creates a new value container for the given type. */
     template <> void MultiType::createNewValueContainer(const bool& value)                 { this->value_ = new MT_Value<bool>                (value, MT_bool       ); } /** @brief Creates a new value container for the given type. */
     template <> void MultiType::createNewValueContainer(      void* const& value)          { this->value_ = new MT_Value<void*>               (value, MT_void       ); } /** @brief Creates a new value container for the given type. */
     template <> void MultiType::createNewValueContainer(const std::string& value)          { this->value_ = new MT_Value<std::string>         (value, MT_string     ); } /** @brief Creates a new value container for the given type. */
     template <> void MultiType::createNewValueContainer(const orxonox::Vector2& value)     { this->value_ = new MT_Value<orxonox::Vector2>    (value, MT_vector2    ); } /** @brief Creates a new value container for the given type. */
     template <> void MultiType::createNewValueContainer(const orxonox::Vector3& value)     { this->value_ = new MT_Value<orxonox::Vector3>    (value, MT_vector3    ); } /** @brief Creates a new value container for the given type. */
     template <> void MultiType::createNewValueContainer(const orxonox::Vector4& value)     { this->value_ = new MT_Value<orxonox::Vector4>    (value, MT_vector4    ); } /** @brief Creates a new value container for the given type. */
     template <> void MultiType::createNewValueContainer(const orxonox::ColourValue& value) { this->value_ = new MT_Value<orxonox::ColourValue>(value, MT_colourvalue); } /** @brief Creates a new value container for the given type. */
     template <> void MultiType::createNewValueContainer(const orxonox::Quaternion& value)  { this->value_ = new MT_Value<orxonox::Quaternion> (value, MT_quaternion ); } /** @brief Creates a new value container for the given type. */
     template <> void MultiType::createNewValueContainer(const orxonox::Radian& value)      { this->value_ = new MT_Value<orxonox::Radian>     (value, MT_radian     ); } /** @brief Creates a new value container for the given type. */
     template <> void MultiType::createNewValueContainer(const orxonox::Degree& value)      { this->value_ = new MT_Value<orxonox::Degree>     (value, MT_degree     ); } /** @brief Creates a new value container for the given type. */
+    MultiType::operator char()                 const { return (this->value_) ? ((this->value_->type_ == MT_Type::Char            ) ? (static_cast<MT_Value<char>                *>(this->value_))->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator unsigned char()        const { return (this->value_) ? ((this->value_->type_ == MT_Type::UnsignedChar    ) ? (static_cast<MT_Value<unsigned char>       *>(this->value_))->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator short()                const { return (this->value_) ? ((this->value_->type_ == MT_Type::Short           ) ? (static_cast<MT_Value<short>               *>(this->value_))->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator unsigned short()       const { return (this->value_) ? ((this->value_->type_ == MT_Type::UnsignedShort   ) ? (static_cast<MT_Value<unsigned short>      *>(this->value_))->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator int()                  const { return (this->value_) ? ((this->value_->type_ == MT_Type::Int             ) ? (static_cast<MT_Value<int>                 *>(this->value_))->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator unsigned int()         const { return (this->value_) ? ((this->value_->type_ == MT_Type::UnsignedInt     ) ? (static_cast<MT_Value<unsigned int>        *>(this->value_))->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator long()                 const { return (this->value_) ? ((this->value_->type_ == MT_Type::Long            ) ? (static_cast<MT_Value<long>                *>(this->value_))->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator unsigned long()        const { return (this->value_) ? ((this->value_->type_ == MT_Type::UnsignedLong    ) ? (static_cast<MT_Value<unsigned long>       *>(this->value_))->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator long long()            const { return (this->value_) ? ((this->value_->type_ == MT_Type::LongLong        ) ? (static_cast<MT_Value<long long>           *>(this->value_))->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator unsigned long long()   const { return (this->value_) ? ((this->value_->type_ == MT_Type::UnsignedLongLong) ? (static_cast<MT_Value<unsigned long long>  *>(this->value_))->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator float()                const { return (this->value_) ? ((this->value_->type_ == MT_Type::Float           ) ? (static_cast<MT_Value<float>               *>(this->value_))->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator double()               const { return (this->value_) ? ((this->value_->type_ == MT_Type::Double          ) ? (static_cast<MT_Value<double>              *>(this->value_))->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator long double()          const { return (this->value_) ? ((this->value_->type_ == MT_Type::LongDouble      ) ? (static_cast<MT_Value<long double>         *>(this->value_))->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator bool()                 const { return (this->value_) ? ((this->value_->type_ == MT_Type::Bool            ) ? (static_cast<MT_Value<bool>                *>(this->value_))->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator void*()                const { return (this->value_) ? ((this->value_->type_ == MT_Type::VoidPointer     ) ? (static_cast<MT_Value<void*>               *>(this->value_))->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator std::string()          const { return (this->value_) ? ((this->value_->type_ == MT_Type::String          ) ? (static_cast<MT_Value<std::string>         *>(this->value_))->value_ : (*this->value_)) : NilValue<std::string>();          } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator orxonox::Vector2()     const { return (this->value_) ? ((this->value_->type_ == MT_Type::Vector2         ) ? (static_cast<MT_Value<orxonox::Vector2>    *>(this->value_))->value_ : (*this->value_)) : NilValue<orxonox::Vector2>();     } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator orxonox::Vector3()     const { return (this->value_) ? ((this->value_->type_ == MT_Type::Vector3         ) ? (static_cast<MT_Value<orxonox::Vector3>    *>(this->value_))->value_ : (*this->value_)) : NilValue<orxonox::Vector3>();     } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator orxonox::Vector4()     const { return (this->value_) ? ((this->value_->type_ == MT_Type::Vector4         ) ? (static_cast<MT_Value<orxonox::Vector4>    *>(this->value_))->value_ : (*this->value_)) : NilValue<orxonox::Vector4>();     } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator orxonox::ColourValue() const { return (this->value_) ? ((this->value_->type_ == MT_Type::ColourValue     ) ? (static_cast<MT_Value<orxonox::ColourValue>*>(this->value_))->value_ : (*this->value_)) : NilValue<orxonox::ColourValue>(); } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator orxonox::Quaternion()  const { return (this->value_) ? ((this->value_->type_ == MT_Type::Quaternion      ) ? (static_cast<MT_Value<orxonox::Quaternion> *>(this->value_))->value_ : (*this->value_)) : NilValue<orxonox::Quaternion>();  } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator orxonox::Radian()      const { return (this->value_) ? ((this->value_->type_ == MT_Type::Radian          ) ? (static_cast<MT_Value<orxonox::Radian>     *>(this->value_))->value_ : (*this->value_)) : NilValue<orxonox::Radian>();      } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator orxonox::Degree()      const { return (this->value_) ? ((this->value_->type_ == MT_Type::Degree          ) ? (static_cast<MT_Value<orxonox::Degree>     *>(this->value_))->value_ : (*this->value_)) : NilValue<orxonox::Degree>();      } /** @brief Returns the current value, converted to the requested type. */
+    template <> void MultiType::createNewValueContainer(const char& value)                 { this->value_ = new MT_Value<char>                (value, MT_Type::Char            ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const unsigned char& value)        { this->value_ = new MT_Value<unsigned char>       (value, MT_Type::UnsignedChar    ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const short& value)                { this->value_ = new MT_Value<short>               (value, MT_Type::Short           ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const unsigned short& value)       { this->value_ = new MT_Value<unsigned short>      (value, MT_Type::UnsignedShort   ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const int& value)                  { this->value_ = new MT_Value<int>                 (value, MT_Type::Int             ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const unsigned int& value)         { this->value_ = new MT_Value<unsigned int>        (value, MT_Type::UnsignedInt     ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const long& value)                 { this->value_ = new MT_Value<long>                (value, MT_Type::Long            ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const unsigned long& value)        { this->value_ = new MT_Value<unsigned long>       (value, MT_Type::UnsignedLong    ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const long long& value)            { this->value_ = new MT_Value<long long>           (value, MT_Type::LongLong        ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const unsigned long long& value)   { this->value_ = new MT_Value<unsigned long long>  (value, MT_Type::UnsignedLongLong); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const float& value)                { this->value_ = new MT_Value<float>               (value, MT_Type::Float           ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const double& value)               { this->value_ = new MT_Value<double>              (value, MT_Type::Double          ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const long double& value)          { this->value_ = new MT_Value<long double>         (value, MT_Type::LongDouble      ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const bool& value)                 { this->value_ = new MT_Value<bool>                (value, MT_Type::Bool            ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(      void* const& value)          { this->value_ = new MT_Value<void*>               (value, MT_Type::VoidPointer     ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const std::string& value)          { this->value_ = new MT_Value<std::string>         (value, MT_Type::String          ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const orxonox::Vector2& value)     { this->value_ = new MT_Value<orxonox::Vector2>    (value, MT_Type::Vector2         ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const orxonox::Vector3& value)     { this->value_ = new MT_Value<orxonox::Vector3>    (value, MT_Type::Vector3         ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const orxonox::Vector4& value)     { this->value_ = new MT_Value<orxonox::Vector4>    (value, MT_Type::Vector4         ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const orxonox::ColourValue& value) { this->value_ = new MT_Value<orxonox::ColourValue>(value, MT_Type::ColourValue     ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const orxonox::Quaternion& value)  { this->value_ = new MT_Value<orxonox::Quaternion> (value, MT_Type::Quaternion      ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const orxonox::Radian& value)      { this->value_ = new MT_Value<orxonox::Radian>     (value, MT_Type::Radian          ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const orxonox::Degree& value)      { this->value_ = new MT_Value<orxonox::Degree>     (value, MT_Type::Degree          ); } /** @brief Creates a new value container for the given type. */
+}

code/trunk/src/util/MultiType.h

-                      r3241
+                      r3280
         @brief Enum of all possible types of a MultiType.
     */
     enum MT_Type
+    namespace MT_Type
+    {
+        MT_null=0,
+        MT_char=1,
+        MT_uchar=2,
+        MT_short=3,
+        MT_ushort=4,
+        MT_int=5,
+        MT_uint=6,
+        MT_long=7,
+        MT_ulong=8,
+        MT_longlong=9,
+        MT_ulonglong=10,
+        MT_float=11,
+        MT_double=12,
+        MT_longdouble=13,
+        MT_bool=14,
+        MT_void=15,
+        MT_string=16,
+        MT_vector2=17,
+        MT_vector3=18,
+        MT_vector4=19,
+        MT_colourvalue=20,
+        MT_quaternion=21,
+        MT_radian=22,
+        MT_degree=23
+    };
+        enum Value
+        {
+            Null,
+            Char,
+            UnsignedChar,
+            Short,
+            UnsignedShort,
+            Int,
+            UnsignedInt,
+            Long,
+            UnsignedLong,
+            LongLong,
+            UnsignedLongLong,
+            Float,
+            Double,
+            LongDouble,
+            Bool,
+            VoidPointer,
+            String,
+            Vector2,
+            Vector3,
+            Vector4,
+            ColourValue,
+            Quaternion,
+            Radian,
+            Degree
+        };
+    }
     /**
 …
+        {
         public:
             MT_ValueBase(MT_Type type) : type_(type), bHasDefaultValue_(false) {}
+            MT_ValueBase(MT_Type::Value type) : type_(type), bHasDefaultValue_(false) {}
             virtual ~MT_ValueBase() {}
 …
             /** @brief Returns the type of the current value. */
             const MT_Type& getType() const { return this->type_; }
+            const MT_Type::Value& getType() const { return this->type_; }
             /** @brief Checks whether the value is a default one. */
 …
             virtual uint8_t getSize() const=0;
             MT_Type type_;          //!< The type of the current value
+            MT_Type::Value type_;   //!< The type of the current value
             bool bHasDefaultValue_; //!< True if the last conversion wasn't successful
         };
 …
             inline MultiType(const char* value)                 : value_(0) { this->setValue(std::string(value)); } /** @brief Constructor: Converts the char array to a std::string, assigns the value and sets the type. */
             inline MultiType(const MultiType& other)            : value_(0) { this->setValue(other); }              /** @brief Copyconstructor: Assigns value and type of the other MultiType. */
             inline MultiType(MT_Type type)                      : value_(0) { this->setType(type); }                /** @brief Constructor: Sets the type, the next assignment will determine the value. */
+            inline MultiType(MT_Type::Value type)               : value_(0) { this->setType(type); }                /** @brief Constructor: Sets the type, the next assignment will determine the value. */
             /** @brief Destructor: Deletes the MT_Value. */
 …
             template <typename V> inline const MultiType& operator=(V* value)               { this->setValue(value); return (*this); } /** @brief Assigns a pointer. */
             inline                       const MultiType& operator=(const MultiType& other) { this->setValue(other); return (*this); } /** @brief Assigns the value of the other MultiType and converts it to the current type of the MultiType. */
             inline                       const MultiType& operator=(MT_Type type)           { this->setType(type);   return (*this); } /** @brief Resets the value and changes the type. */
+            inline                       const MultiType& operator=(MT_Type::Value type)    { this->setType(type);   return (*this); } /** @brief Resets the value and changes the type. */
             inline bool                                   setValue(const char& value);
 …
             template <typename T> inline bool convert()                       { return this->setValue<T>((T)(*this));  } /** @brief Converts the current value to type T. */
             inline bool                       convert(const MultiType& other) { return this->convert(other.getType()); } /** @brief Converts the current value to the type of the other MultiType. */
             bool                              convert(MT_Type type);
             /** @brief Current content gets deleted. New type is MT_null */
+            bool                              convert(MT_Type::Value type);
+            /** @brief Current content gets deleted. New type is MT_Type::Null */
             inline void                       reset()                         { if (this->value_) delete this->value_; this->value_ = 0; }
             /** @brief Current content gets overridden with default zero value */
 …
             template <typename T> inline void setType()                       { this->assignValue(typename TypeStripper<T>::RawType()); } /** @brief Resets the value and changes the internal type to T. */
             inline void                       setType(const MultiType& other) { this->setType(other.getType());                         } /** @brief Resets the value and changes the internal type to the type of the other MultiType. */
             inline void                       setType(MT_Type type)           { this->reset(); this->convert(type); this->resetValue(); } /** @brief Resets the value and changes the internal type to the given type. */
+            inline void                       setType(MT_Type::Value type)    { this->reset(); this->convert(type); this->resetValue(); } /** @brief Resets the value and changes the internal type to the given type. */
             /** @brief Returns the current type. */
             inline MT_Type                    getType()                 const { return (this->value_) ? this->value_->type_ : MT_null; }
+            inline MT_Type::Value             getType()                   const { return (this->value_) ? this->value_->type_ : MT_Type::Null; }
             /** @brief Returns true if the current type equals the given type. */
             inline bool                       isType(MT_Type type)      const { return (this->value_) ? (this->value_->type_ == type) : (type == MT_null); }
+            inline bool                       isType(MT_Type::Value type) const { return (this->value_) ? (this->value_->type_ == type) : (type == MT_Type::Null); }
             /** @brief Returns true if the current type is T. */
             template <typename T> inline bool isType()                  const { return false; } // Only works for specialized values - see below
             std::string                       getTypename()             const;
+            template <typename T> inline bool isType()                    const { return false; } // Only works for specialized values - see below
+            std::string                       getTypename()               const;
             /** @brief Saves the value of the MT to a bytestream (pointed at by mem) and increases mem pointer by size of MT */
             inline void                       exportData(uint8_t*& mem) const { assert(sizeof(MT_Type)<=8); *(uint8_t*)(mem) = this->getType(); mem+=sizeof(uint8_t); this->value_->exportData(mem); }
+            inline void                       exportData(uint8_t*& mem) const { assert(sizeof(MT_Type::Value)<=8); *(uint8_t*)(mem) = this->getType(); mem+=sizeof(uint8_t); this->value_->exportData(mem); }
             /** @brief Loads the value of the MT from a bytestream (pointed at by mem) and increases mem pointer by size of MT */
             inline void                       importData(uint8_t*& mem) { assert(sizeof(MT_Type)<=8); this->setType(static_cast<MT_Type>(*(uint8_t*)mem)); mem+=sizeof(uint8_t); this->value_->importData(mem); }
+            inline void                       importData(uint8_t*& mem) { assert(sizeof(MT_Type::Value)<=8); this->setType(static_cast<MT_Type::Value>(*(uint8_t*)mem)); mem+=sizeof(uint8_t); this->value_->importData(mem); }
             /** @brief Saves the value of the MT to a bytestream and increases pointer to bytestream by size of MT */
             inline uint8_t*&                  operator << (uint8_t*& mem) { importData(mem); return mem; }
 …
         private:
             inline bool assignValue(const char& value)                 { if (this->value_ && this->value_->type_ == MT_char)        { return this->value_->setValue(value); } else { this->changeValueContainer<char>(value);                 return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
             inline bool assignValue(const unsigned char& value)        { if (this->value_ && this->value_->type_ == MT_uchar)       { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned char>(value);        return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
             inline bool assignValue(const short& value)                { if (this->value_ && this->value_->type_ == MT_short)       { return this->value_->setValue(value); } else { this->changeValueContainer<short>(value);                return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
             inline bool assignValue(const unsigned short& value)       { if (this->value_ && this->value_->type_ == MT_ushort)      { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned short>(value);       return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
             inline bool assignValue(const int& value)                  { if (this->value_ && this->value_->type_ == MT_int)         { return this->value_->setValue(value); } else { this->changeValueContainer<int>(value);                  return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
             inline bool assignValue(const unsigned int& value)         { if (this->value_ && this->value_->type_ == MT_uint)        { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned int>(value);         return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
             inline bool assignValue(const long& value)                 { if (this->value_ && this->value_->type_ == MT_long)        { return this->value_->setValue(value); } else { this->changeValueContainer<long>(value);                 return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
             inline bool assignValue(const unsigned long& value)        { if (this->value_ && this->value_->type_ == MT_ulong)       { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned long>(value);        return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
             inline bool assignValue(const long long& value)            { if (this->value_ && this->value_->type_ == MT_longlong)    { return this->value_->setValue(value); } else { this->changeValueContainer<long long>(value);            return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
             inline bool assignValue(const unsigned long long& value)   { if (this->value_ && this->value_->type_ == MT_ulonglong)   { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned long long>(value);   return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
             inline bool assignValue(const float& value)                { if (this->value_ && this->value_->type_ == MT_float)       { return this->value_->setValue(value); } else { this->changeValueContainer<float>(value);                return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
             inline bool assignValue(const double& value)               { if (this->value_ && this->value_->type_ == MT_double)      { return this->value_->setValue(value); } else { this->changeValueContainer<double>(value);               return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
             inline bool assignValue(const long double& value)          { if (this->value_ && this->value_->type_ == MT_longdouble)  { return this->value_->setValue(value); } else { this->changeValueContainer<long double>(value);          return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
             inline bool assignValue(const bool& value)                 { if (this->value_ && this->value_->type_ == MT_bool)        { return this->value_->setValue(value); } else { this->changeValueContainer<bool>(value);                 return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
             inline bool assignValue(      void* const& value)          { if (this->value_ && this->value_->type_ == MT_void)        { return this->value_->setValue(value); } else { this->changeValueContainer<void*>(value);                return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
             inline bool assignValue(const std::string& value)          { if (this->value_ && this->value_->type_ == MT_string)      { return this->value_->setValue(value); } else { this->changeValueContainer<std::string>(value);          return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
             inline bool assignValue(const orxonox::Vector2& value)     { if (this->value_ && this->value_->type_ == MT_vector2)     { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Vector2>(value);     return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
             inline bool assignValue(const orxonox::Vector3& value)     { if (this->value_ && this->value_->type_ == MT_vector3)     { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Vector3>(value);     return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
             inline bool assignValue(const orxonox::Vector4& value)     { if (this->value_ && this->value_->type_ == MT_vector4)     { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Vector4>(value);     return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
             inline bool assignValue(const orxonox::ColourValue& value) { if (this->value_ && this->value_->type_ == MT_colourvalue) { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::ColourValue>(value); return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
             inline bool assignValue(const orxonox::Quaternion& value)  { if (this->value_ && this->value_->type_ == MT_quaternion)  { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Quaternion>(value);  return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
             inline bool assignValue(const orxonox::Radian& value)      { if (this->value_ && this->value_->type_ == MT_radian)      { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Radian>(value);      return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
             inline bool assignValue(const orxonox::Degree& value)      { if (this->value_ && this->value_->type_ == MT_degree)      { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Degree>(value);      return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const char& value)                 { if (this->value_ && this->value_->type_ == MT_Type::Char)             { return this->value_->setValue(value); } else { this->changeValueContainer<char>(value);                 return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const unsigned char& value)        { if (this->value_ && this->value_->type_ == MT_Type::UnsignedChar)     { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned char>(value);        return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const short& value)                { if (this->value_ && this->value_->type_ == MT_Type::Short)            { return this->value_->setValue(value); } else { this->changeValueContainer<short>(value);                return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const unsigned short& value)       { if (this->value_ && this->value_->type_ == MT_Type::UnsignedShort)    { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned short>(value);       return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const int& value)                  { if (this->value_ && this->value_->type_ == MT_Type::Int)              { return this->value_->setValue(value); } else { this->changeValueContainer<int>(value);                  return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const unsigned int& value)         { if (this->value_ && this->value_->type_ == MT_Type::UnsignedInt)      { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned int>(value);         return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const long& value)                 { if (this->value_ && this->value_->type_ == MT_Type::Long)             { return this->value_->setValue(value); } else { this->changeValueContainer<long>(value);                 return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const unsigned long& value)        { if (this->value_ && this->value_->type_ == MT_Type::UnsignedLong)     { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned long>(value);        return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const long long& value)            { if (this->value_ && this->value_->type_ == MT_Type::LongLong)         { return this->value_->setValue(value); } else { this->changeValueContainer<long long>(value);            return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const unsigned long long& value)   { if (this->value_ && this->value_->type_ == MT_Type::UnsignedLongLong) { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned long long>(value);   return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const float& value)                { if (this->value_ && this->value_->type_ == MT_Type::Float)            { return this->value_->setValue(value); } else { this->changeValueContainer<float>(value);                return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const double& value)               { if (this->value_ && this->value_->type_ == MT_Type::Double)           { return this->value_->setValue(value); } else { this->changeValueContainer<double>(value);               return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const long double& value)          { if (this->value_ && this->value_->type_ == MT_Type::LongDouble)       { return this->value_->setValue(value); } else { this->changeValueContainer<long double>(value);          return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const bool& value)                 { if (this->value_ && this->value_->type_ == MT_Type::Bool)             { return this->value_->setValue(value); } else { this->changeValueContainer<bool>(value);                 return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(      void* const& value)          { if (this->value_ && this->value_->type_ == MT_Type::VoidPointer)      { return this->value_->setValue(value); } else { this->changeValueContainer<void*>(value);                return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const std::string& value)          { if (this->value_ && this->value_->type_ == MT_Type::String)           { return this->value_->setValue(value); } else { this->changeValueContainer<std::string>(value);          return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const orxonox::Vector2& value)     { if (this->value_ && this->value_->type_ == MT_Type::Vector2)          { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Vector2>(value);     return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const orxonox::Vector3& value)     { if (this->value_ && this->value_->type_ == MT_Type::Vector3)          { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Vector3>(value);     return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const orxonox::Vector4& value)     { if (this->value_ && this->value_->type_ == MT_Type::Vector4)          { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Vector4>(value);     return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const orxonox::ColourValue& value) { if (this->value_ && this->value_->type_ == MT_Type::ColourValue)      { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::ColourValue>(value); return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const orxonox::Quaternion& value)  { if (this->value_ && this->value_->type_ == MT_Type::Quaternion)       { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Quaternion>(value);  return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const orxonox::Radian& value)      { if (this->value_ && this->value_->type_ == MT_Type::Radian)           { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Radian>(value);      return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const orxonox::Degree& value)      { if (this->value_ && this->value_->type_ == MT_Type::Degree)           { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Degree>(value);      return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
             /** @brief Changes the value container. */
 …
     _UtilExport inline std::ostream& operator<<(std::ostream& outstream, const MultiType& mt) { if (mt.value_) { mt.value_->toString(outstream); } return outstream; }
     template <> inline bool MultiType::isType<char>()                 const { return (this->value_ && this->value_->type_ == MT_char);        } /** @brief Returns true if the current type equals the given type. */
     template <> inline bool MultiType::isType<unsigned char>()        const { return (this->value_ && this->value_->type_ == MT_uchar);       } /** @brief Returns true if the current type equals the given type. */
     template <> inline bool MultiType::isType<short>()                const { return (this->value_ && this->value_->type_ == MT_short);       } /** @brief Returns true if the current type equals the given type. */
     template <> inline bool MultiType::isType<unsigned short>()       const { return (this->value_ && this->value_->type_ == MT_ushort);      } /** @brief Returns true if the current type equals the given type. */
     template <> inline bool MultiType::isType<int>()                  const { return (this->value_ && this->value_->type_ == MT_int);         } /** @brief Returns true if the current type equals the given type. */
     template <> inline bool MultiType::isType<unsigned int>()         const { return (this->value_ && this->value_->type_ == MT_uint);        } /** @brief Returns true if the current type equals the given type. */
     template <> inline bool MultiType::isType<long>()                 const { return (this->value_ && this->value_->type_ == MT_long);        } /** @brief Returns true if the current type equals the given type. */
     template <> inline bool MultiType::isType<unsigned long>()        const { return (this->value_ && this->value_->type_ == MT_ulong);       } /** @brief Returns true if the current type equals the given type. */
     template <> inline bool MultiType::isType<long long>()            const { return (this->value_ && this->value_->type_ == MT_longlong);    } /** @brief Returns true if the current type equals the given type. */
     template <> inline bool MultiType::isType<unsigned long long>()   const { return (this->value_ && this->value_->type_ == MT_ulonglong);   } /** @brief Returns true if the current type equals the given type. */
     template <> inline bool MultiType::isType<float>()                const { return (this->value_ && this->value_->type_ == MT_float);       } /** @brief Returns true if the current type equals the given type. */
     template <> inline bool MultiType::isType<double>()               const { return (this->value_ && this->value_->type_ == MT_double);      } /** @brief Returns true if the current type equals the given type. */
     template <> inline bool MultiType::isType<long double>()          const { return (this->value_ && this->value_->type_ == MT_longdouble);  } /** @brief Returns true if the current type equals the given type. */
     template <> inline bool MultiType::isType<bool>()                 const { return (this->value_ && this->value_->type_ == MT_bool);        } /** @brief Returns true if the current type equals the given type. */
     template <> inline bool MultiType::isType<void*>()                const { return (this->value_ && this->value_->type_ == MT_void);        } /** @brief Returns true if the current type equals the given type. */
     template <> inline bool MultiType::isType<std::string>()          const { return (this->value_ && this->value_->type_ == MT_string);      } /** @brief Returns true if the current type equals the given type. */
     template <> inline bool MultiType::isType<orxonox::Vector2>()     const { return (this->value_ && this->value_->type_ == MT_vector2);     } /** @brief Returns true if the current type equals the given type. */
     template <> inline bool MultiType::isType<orxonox::Vector3>()     const { return (this->value_ && this->value_->type_ == MT_vector3);     } /** @brief Returns true if the current type equals the given type. */
     template <> inline bool MultiType::isType<orxonox::Vector4>()     const { return (this->value_ && this->value_->type_ == MT_vector4);     } /** @brief Returns true if the current type equals the given type. */
     template <> inline bool MultiType::isType<orxonox::ColourValue>() const { return (this->value_ && this->value_->type_ == MT_colourvalue); } /** @brief Returns true if the current type equals the given type. */
     template <> inline bool MultiType::isType<orxonox::Quaternion>()  const { return (this->value_ && this->value_->type_ == MT_quaternion);  } /** @brief Returns true if the current type equals the given type. */
     template <> inline bool MultiType::isType<orxonox::Radian>()      const { return (this->value_ && this->value_->type_ == MT_radian);      } /** @brief Returns true if the current type equals the given type. */
     template <> inline bool MultiType::isType<orxonox::Degree>()      const { return (this->value_ && this->value_->type_ == MT_degree);      } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<char>()                 const { return (this->value_ && this->value_->type_ == MT_Type::Char);             } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<unsigned char>()        const { return (this->value_ && this->value_->type_ == MT_Type::UnsignedChar);     } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<short>()                const { return (this->value_ && this->value_->type_ == MT_Type::Short);            } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<unsigned short>()       const { return (this->value_ && this->value_->type_ == MT_Type::UnsignedShort);    } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<int>()                  const { return (this->value_ && this->value_->type_ == MT_Type::Int);              } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<unsigned int>()         const { return (this->value_ && this->value_->type_ == MT_Type::UnsignedInt);      } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<long>()                 const { return (this->value_ && this->value_->type_ == MT_Type::Long);             } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<unsigned long>()        const { return (this->value_ && this->value_->type_ == MT_Type::UnsignedLong);     } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<long long>()            const { return (this->value_ && this->value_->type_ == MT_Type::LongLong);         } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<unsigned long long>()   const { return (this->value_ && this->value_->type_ == MT_Type::UnsignedLongLong); } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<float>()                const { return (this->value_ && this->value_->type_ == MT_Type::Float);            } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<double>()               const { return (this->value_ && this->value_->type_ == MT_Type::Double);           } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<long double>()          const { return (this->value_ && this->value_->type_ == MT_Type::LongDouble);       } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<bool>()                 const { return (this->value_ && this->value_->type_ == MT_Type::Bool);             } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<void*>()                const { return (this->value_ && this->value_->type_ == MT_Type::VoidPointer);      } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<std::string>()          const { return (this->value_ && this->value_->type_ == MT_Type::String);           } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<orxonox::Vector2>()     const { return (this->value_ && this->value_->type_ == MT_Type::Vector2);          } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<orxonox::Vector3>()     const { return (this->value_ && this->value_->type_ == MT_Type::Vector3);          } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<orxonox::Vector4>()     const { return (this->value_ && this->value_->type_ == MT_Type::Vector4);          } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<orxonox::ColourValue>() const { return (this->value_ && this->value_->type_ == MT_Type::ColourValue);      } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<orxonox::Quaternion>()  const { return (this->value_ && this->value_->type_ == MT_Type::Quaternion);       } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<orxonox::Radian>()      const { return (this->value_ && this->value_->type_ == MT_Type::Radian);           } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<orxonox::Degree>()      const { return (this->value_ && this->value_->type_ == MT_Type::Degree);           } /** @brief Returns true if the current type equals the given type. */
     // Specialization to avoid ambiguities with the conversion operator

code/trunk/src/util/MultiTypeValue.h

-                      r3196
+                      r3280
     public:
         /** @brief Constructor: Assigns the value and the type identifier. */
         MT_Value(const T& value, MT_Type type) : MT_ValueBase(type), value_(value) {}
+        MT_Value(const T& value, MT_Type::Value type) : MT_ValueBase(type), value_(value) {}
         /** @brief Creates a copy of itself. */
 …
         inline operator bool()                 const { return getConvertedValue<T, bool>                (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
         inline operator void*()                const { return getConvertedValue<T, void*>               (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
         inline operator std::string()          const { return getConvertedValue<T, std::string>         (this->value_, zeroise<std::string         >()); } /** @brief Returns the current value, converted to the requested type. */
         inline operator orxonox::Vector2()     const { return getConvertedValue<T, orxonox::Vector2>    (this->value_, zeroise<orxonox::Vector2    >()); } /** @brief Returns the current value, converted to the requested type. */
         inline operator orxonox::Vector3()     const { return getConvertedValue<T, orxonox::Vector3>    (this->value_, zeroise<orxonox::Vector3    >()); } /** @brief Returns the current value, converted to the requested type. */
         inline operator orxonox::Vector4()     const { return getConvertedValue<T, orxonox::Vector4>    (this->value_, zeroise<orxonox::Vector4    >()); } /** @brief Returns the current value, converted to the requested type. */
         inline operator orxonox::ColourValue() const { return getConvertedValue<T, orxonox::ColourValue>(this->value_, zeroise<orxonox::ColourValue>()); } /** @brief Returns the current value, converted to the requested type. */
         inline operator orxonox::Quaternion()  const { return getConvertedValue<T, orxonox::Quaternion> (this->value_, zeroise<orxonox::Quaternion >()); } /** @brief Returns the current value, converted to the requested type. */
         inline operator orxonox::Radian()      const { return getConvertedValue<T, orxonox::Radian>     (this->value_, zeroise<orxonox::Radian     >()); } /** @brief Returns the current value, converted to the requested type. */
         inline operator orxonox::Degree()      const { return getConvertedValue<T, orxonox::Degree>     (this->value_, zeroise<orxonox::Degree     >()); } /** @brief Returns the current value, converted to the requested type. */
+        inline operator std::string()          const { return getConvertedValue<T, std::string>         (this->value_, NilValue<std::string         >()); } /** @brief Returns the current value, converted to the requested type. */
+        inline operator orxonox::Vector2()     const { return getConvertedValue<T, orxonox::Vector2>    (this->value_, NilValue<orxonox::Vector2    >()); } /** @brief Returns the current value, converted to the requested type. */
+        inline operator orxonox::Vector3()     const { return getConvertedValue<T, orxonox::Vector3>    (this->value_, NilValue<orxonox::Vector3    >()); } /** @brief Returns the current value, converted to the requested type. */
+        inline operator orxonox::Vector4()     const { return getConvertedValue<T, orxonox::Vector4>    (this->value_, NilValue<orxonox::Vector4    >()); } /** @brief Returns the current value, converted to the requested type. */
+        inline operator orxonox::ColourValue() const { return getConvertedValue<T, orxonox::ColourValue>(this->value_, NilValue<orxonox::ColourValue>()); } /** @brief Returns the current value, converted to the requested type. */
+        inline operator orxonox::Quaternion()  const { return getConvertedValue<T, orxonox::Quaternion> (this->value_, NilValue<orxonox::Quaternion >()); } /** @brief Returns the current value, converted to the requested type. */
+        inline operator orxonox::Radian()      const { return getConvertedValue<T, orxonox::Radian>     (this->value_, NilValue<orxonox::Radian     >()); } /** @brief Returns the current value, converted to the requested type. */
+        inline operator orxonox::Degree()      const { return getConvertedValue<T, orxonox::Degree>     (this->value_, NilValue<orxonox::Degree     >()); } /** @brief Returns the current value, converted to the requested type. */
         /** @brief Puts the current value on the stream */

code/trunk/src/util/StringUtils.cc

r3251	r3280
44	44	std::string getUniqueNumberString()
45	45	{
46		return ~~convertToString~~(getUniqueNumber());
	46	return multi_cast<std::string>(getUniqueNumber());
47	47	}
48	48

code/trunk/src/util/UtilPrereqs.h

-                      r3196
+                      r3280
 // Forward declarations
 //-----------------------------------------------------------------------
+namespace orxonox
+{
+    class Exception;
+    class ExprParser;
+    class IntVector2;
+    class IntVector3;
+    class MultiType;
+    class OutputBuffer;
+    class OutputBufferListener;
+    class OutputHandler;
+    class SignalHandler;
+    class SubString;
+}
 namespace Ogre
+{
 …
     class ColourValue;
+}
 namespace orxonox
+{
 …
     using Ogre::Quaternion;
     using Ogre::ColourValue;
+}
+    class Exception;
+    class ExprParser;
+    class IntVector2;
+    class IntVector3;
+    class MultiType;
+    class OutputBuffer;
+    class OutputBufferListener;
+    class OutputHandler;
+    class SignalHandler;
+    class SubString;
+namespace Loki
+{
+    class ScopeGuardImplBase;
+    typedef const ScopeGuardImplBase& ScopeGuard;
+}

Context Navigation

Legend: