Index: code/branches/core/src/util/CMakeLists.txt
===================================================================
--- code/branches/core/src/util/CMakeLists.txt	(revision 791)
+++ code/branches/core/src/util/CMakeLists.txt	(revision 792)
@@ -5,16 +5,20 @@
 SET (UTIL_SRC_FILES
   ${TINYXML_SRC_FILES}
+  Math.cc
+  String.cc
   substring.cc
+  MultiTypePrimitive.cc
+  MultiTypeString.cc
+  MultiTypeMath.cc
 )
 
-IF(WIN32)
-  ADD_LIBRARY( util ${UTIL_SRC_FILES} )
-ELSE(WIN32)
-  ADD_LIBRARY( util SHARED ${UTIL_SRC_FILES} )
-ENDIF(WIN32)
+ADD_LIBRARY( util SHARED ${UTIL_SRC_FILES} )
 SET_TARGET_PROPERTIES( util PROPERTIES LINK_FLAGS "--no-undefined" )
-
 
 IF(TESTING_ENABLED)
   ADD_SUBDIRECTORY(testing)
 ENDIF(TESTING_ENABLED)
+
+TARGET_LINK_LIBRARIES( util
+  ${OGRE_LIBRARIES}
+)
Index: code/branches/core/src/util/Convert.h
===================================================================
--- code/branches/core/src/util/Convert.h	(revision 791)
+++ code/branches/core/src/util/Convert.h	(revision 792)
@@ -36,8 +36,9 @@
 #include <sstream>
 
+#include "UtilPrereqs.h"
 
 // DEFAULT CLASS
 template <typename FromType, typename ToType>
-class Converter
+class _UtilExport Converter
 {
  public:
@@ -50,5 +51,5 @@
 // PARTIAL SPECIALIZATION TO CONVERT TO STRINGS
 template<typename FromType>
-class Converter<FromType, std::string>
+class _UtilExport Converter<FromType, std::string>
 {
  public:
@@ -68,5 +69,5 @@
 // PARTIAL SPECIALIZATION TO CONVERT FROM STRING
 template<typename ToType>
-class Converter<std::string, ToType>
+class _UtilExport Converter<std::string, ToType>
 {
  public:
@@ -83,5 +84,5 @@
 // FUNCTION SO WE DO NOT HAVE TO TELL THE COMPILER ABOUT THE TYPE
 template<typename FromType, typename ToType>
-static bool ConvertValue(ToType* output, const FromType& input)
+static _UtilExport bool ConvertValue(ToType* output, const FromType& input)
 {
   Converter<FromType, ToType> converter;
@@ -91,5 +92,5 @@
 // THE SAME, BUT WITH DEFAULT VALUE
 template<typename FromType, typename ToType>
-static bool ConvertValue(ToType* output, const FromType& input, const ToType& fallback)
+static _UtilExport bool ConvertValue(ToType* output, const FromType& input, const ToType& fallback)
 {
   Converter<FromType, ToType> converter;
Index: code/branches/core/src/util/Math.cc
===================================================================
--- code/branches/core/src/util/Math.cc	(revision 792)
+++ code/branches/core/src/util/Math.cc	(revision 792)
@@ -0,0 +1,68 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Fabian 'x3n' Landau
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#include "Math.h"
+
+/**
+    @brief Function for writing to a stream.
+*/
+std::ostream& operator<<(std::ostream& out, const orxonox::Radian& radian)
+{
+    out << radian.valueRadians();
+    return out;
+}
+
+/**
+    @brief Function for reading from a stream.
+*/
+std::istream& operator>>(std::istream& in, orxonox::Radian& radian)
+{
+    float temp;
+    in >> temp;
+    radian = temp;
+    return in;
+}
+
+/**
+    @brief Function for writing to a stream.
+*/
+std::ostream& operator<<(std::ostream& out, const orxonox::Degree& degree)
+{
+    out << degree.valueDegrees();
+    return out;
+}
+
+/**
+    @brief Function for reading from a stream.
+*/
+std::istream& operator>>(std::istream& in, orxonox::Degree& degree)
+{
+    float temp;
+    in >> temp;
+    degree = temp;
+    return in;
+}
Index: code/branches/core/src/util/Math.h
===================================================================
--- code/branches/core/src/util/Math.h	(revision 791)
+++ code/branches/core/src/util/Math.h	(revision 792)
@@ -1,2 +1,36 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Fabian 'x3n' Landau
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#ifndef _Math_H__
+#define _Math_H__
+
+#include <ostream>
+
+#include "UtilPrereqs.h"
+
 #include <OgreMath.h>
 #include <OgreVector2.h>
@@ -18,2 +52,97 @@
   typedef Ogre::ColourValue ColourValue;
 }
+
+_UtilExport std::ostream& operator<<(std::ostream& out, const orxonox::Radian& radian);
+_UtilExport std::istream& operator>>(std::istream& in, orxonox::Radian& radian);
+_UtilExport std::ostream& operator<<(std::ostream& out, const orxonox::Degree& degree);
+_UtilExport std::istream& operator>>(std::istream& in, orxonox::Degree& degree);
+
+template <typename T>
+inline _UtilExport T sgn(T x)
+{
+    return (x >= 0) ? 1 : -1;
+}
+
+template <typename T>
+inline _UtilExport T min(T a, T b)
+{
+    return (a <= b) ? a : b;
+}
+
+template <typename T>
+inline _UtilExport T max(T a, T b)
+{
+    return (a >= b) ? a : b;
+}
+
+template <typename T>
+inline _UtilExport T clamp(T x, T min, T max)
+{
+    if (x < min)
+        return min;
+
+    if (x > max)
+        return max;
+
+    return x;
+}
+
+template <typename T>
+inline _UtilExport T square(T x)
+{
+    return x*x;
+}
+
+template <typename T>
+inline _UtilExport T cube(T x)
+{
+    return x*x*x;
+}
+
+template <typename T>
+inline _UtilExport int floor(T x)
+{
+    return (int)(x);
+}
+
+template <typename T>
+inline _UtilExport int ceil(T x)
+{
+    int temp = floor(x);
+    return (temp != x) ? (temp + 1) : temp;
+}
+
+template <typename T>
+inline _UtilExport int round(T x)
+{
+    return (int)(x + 0.5);
+}
+
+template <typename T>
+_UtilExport T interpolate(float time, const T& start, const T& end)
+{
+    return time * (end - start) + start;
+}
+
+template <typename T>
+_UtilExport T interpolateSmooth(float time, const T& start, const T& end)
+{
+    return (-2 * (end - start) * cube(time)) + (3 * (end - start) * square(time)) + start;
+}
+
+inline _UtilExport float rnd()
+{
+    return ((float)rand() / RAND_MAX);
+}
+
+inline _UtilExport float rnd(float max)
+{
+    return rnd() * max;
+}
+
+inline _UtilExport float rnd(float min, float max)
+{
+    return rnd(max - min) + min;
+}
+
+#endif /* _Math_H__ */
Index: code/branches/core/src/util/MultiType.h
===================================================================
--- code/branches/core/src/util/MultiType.h	(revision 792)
+++ code/branches/core/src/util/MultiType.h	(revision 792)
@@ -0,0 +1,75 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Fabian 'x3n' Landau
+ *   Co-authors:
+ *      ...
+ *
+ *   Inspiration: MultiType by Benjamin Grauer
+ */
+
+#ifndef _MultiType_H__
+#define _MultiType_H__
+
+#include "UtilPrereqs.h"
+
+enum _UtilExport MultiType
+{
+    MT_null,
+    MT_int,
+    MT_uint,
+    MT_char,
+    MT_uchar,
+    MT_short,
+    MT_ushort,
+    MT_long,
+    MT_ulong,
+    MT_float,
+    MT_double,
+    MT_longdouble,
+    MT_bool,
+    MT_constchar,
+    MT_string,
+    MT_vector2,
+    MT_vector3,
+    MT_colourvalue,
+    MT_quaternion,
+    MT_degree,
+    MT_radian
+};
+
+union _UtilExport MultiTypeValue
+{
+    int             int_;
+    unsigned int    uint_;
+    char            char_;
+    unsigned char   uchar_;
+    short           short_;
+    unsigned short  ushort_;
+    long            long_;
+    unsigned long   ulong_;
+    float           float_;
+    double          double_;
+    long double     longdouble_;
+    bool            bool_;
+};
+
+#endif /* _MultiType_H__ */
Index: code/branches/core/src/util/MultiTypeMath.cc
===================================================================
--- code/branches/core/src/util/MultiTypeMath.cc	(revision 792)
+++ code/branches/core/src/util/MultiTypeMath.cc	(revision 792)
@@ -0,0 +1,106 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Fabian 'x3n' Landau
+ *   Co-authors:
+ *      ...
+ *
+ *   Inspiration: MultiType by Benjamin Grauer
+ */
+
+#include "MultiTypeMath.h"
+
+MultiTypeMath::MultiTypeMath(MultiType type) : MultiTypeString(type)
+{
+    if (type == MT_vector2)
+        this->vector2_ = orxonox::Vector2(0, 0);
+    else if (type == MT_vector3)
+        this->vector3_ = orxonox::Vector3(0, 0, 0);
+    else if (type == MT_colourvalue)
+        this->colourvalue_ = orxonox::ColourValue(0, 0, 0, 0);
+    else if (type == MT_quaternion)
+        this->quaternion_ = orxonox::Quaternion(1, 0, 0, 0);
+    else if (type == MT_radian)
+        this->radian_ = orxonox::Radian(0);
+    else if (type == MT_degree)
+        this->degree_ = orxonox::Degree(0);
+}
+
+MultiTypeMath::MultiTypeMath(const MultiTypeMath& mtm)
+{
+    this->type_ = mtm.type_;
+    this->value_ = mtm.value_;
+}
+
+MultiTypeMath& MultiTypeMath::operator=(const MultiTypeMath& mtm)
+{
+    this->type_ = mtm.type_;
+    this->value_ = mtm.value_;
+    return *this;
+}
+
+bool MultiTypeMath::operator==(const MultiTypeMath& mtm) const
+{
+    if (!MultiTypeString::operator==(mtm) && this->type_ == mtm.type_)
+    {
+        if (this->type_ == MT_vector2)
+            return (this->vector2_ == mtm.vector2_);
+        else if (this->type_ == MT_vector3)
+            return (this->vector3_ == mtm.vector3_);
+        else if (this->type_ == MT_colourvalue)
+            return (this->colourvalue_ == mtm.colourvalue_);
+        else if (this->type_ == MT_quaternion)
+            return (this->quaternion_ == mtm.quaternion_);
+        else if (this->type_ == MT_radian)
+            return (this->radian_ == mtm.radian_);
+        else if (this->type_ == MT_degree)
+            return (this->degree_ == mtm.degree_);
+    }
+
+    return false;
+}
+
+bool MultiTypeMath::operator!=(const MultiTypeMath& mtm) const
+{
+    if (MultiTypeString::operator==(mtm) && this->type_ == mtm.type_)
+    {
+        if (this->type_ == MT_vector2)
+            return (this->vector2_ != mtm.vector2_);
+        else if (this->type_ == MT_vector3)
+            return (this->vector3_ != mtm.vector3_);
+        else if (this->type_ == MT_colourvalue)
+            return (this->colourvalue_ != mtm.colourvalue_);
+        else if (this->type_ == MT_quaternion)
+            return (this->quaternion_ != mtm.quaternion_);
+        else if (this->type_ == MT_radian)
+            return (this->radian_ != mtm.radian_);
+        else if (this->type_ == MT_degree)
+            return (this->degree_ != mtm.degree_);
+    }
+
+    return true;
+}
+
+void MultiTypeMath::setValue(const MultiTypeMath& mtm)
+{
+    this->type_ = mtm.type_;
+    this->value_ = mtm.value_;
+}
Index: code/branches/core/src/util/MultiTypeMath.h
===================================================================
--- code/branches/core/src/util/MultiTypeMath.h	(revision 792)
+++ code/branches/core/src/util/MultiTypeMath.h	(revision 792)
@@ -0,0 +1,118 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Fabian 'x3n' Landau
+ *   Co-authors:
+ *      ...
+ *
+ *   Inspiration: MultiType by Benjamin Grauer
+ */
+
+#ifndef _MultiTypeMath_H__
+#define _MultiTypeMath_H__
+
+#include "UtilPrereqs.h"
+
+#include "MultiTypeString.h"
+#include "Math.h"
+
+class _UtilExport MultiTypeMath : public MultiTypeString
+{
+    public:
+        MultiTypeMath(MultiType      type = MT_null);
+        MultiTypeMath(int            value) : MultiTypeString(value) {}
+        MultiTypeMath(unsigned int   value) : MultiTypeString(value) {}
+        MultiTypeMath(char           value) : MultiTypeString(value) {}
+        MultiTypeMath(unsigned char  value) : MultiTypeString(value) {}
+        MultiTypeMath(short          value) : MultiTypeString(value) {}
+        MultiTypeMath(unsigned short value) : MultiTypeString(value) {}
+        MultiTypeMath(long           value) : MultiTypeString(value) {}
+        MultiTypeMath(unsigned long  value) : MultiTypeString(value) {}
+        MultiTypeMath(float          value) : MultiTypeString(value) {}
+        MultiTypeMath(double         value) : MultiTypeString(value) {}
+        MultiTypeMath(long double    value) : MultiTypeString(value) {}
+        MultiTypeMath(bool           value) : MultiTypeString(value) {}
+        MultiTypeMath(const char*        value) : MultiTypeString(value) {}
+        MultiTypeMath(const std::string& value) : MultiTypeString(value) {}
+        MultiTypeMath(const orxonox::Vector2&     value) { this->setValue(value); }
+        MultiTypeMath(const orxonox::Vector3&     value) { this->setValue(value); }
+        MultiTypeMath(const orxonox::ColourValue& value) { this->setValue(value); }
+        MultiTypeMath(const orxonox::Quaternion&  value) { this->setValue(value); }
+        MultiTypeMath(const orxonox::Radian&      value) { this->setValue(value); }
+        MultiTypeMath(const orxonox::Degree&      value) { this->setValue(value); }
+        MultiTypeMath(const MultiTypeMath& mtm);
+
+        MultiTypeMath& operator=(const orxonox::Vector2&     value) { this->setValue(value); return *this; }
+        MultiTypeMath& operator=(const orxonox::Vector3&     value) { this->setValue(value); return *this; }
+        MultiTypeMath& operator=(const orxonox::ColourValue& value) { this->setValue(value); return *this; }
+        MultiTypeMath& operator=(const orxonox::Quaternion&  value) { this->setValue(value); return *this; }
+        MultiTypeMath& operator=(const orxonox::Radian&      value) { this->setValue(value); return *this; }
+        MultiTypeMath& operator=(const orxonox::Degree&      value) { this->setValue(value); return *this; }
+        MultiTypeMath& operator=(const MultiTypeMath& mtm);
+
+        bool operator==(const orxonox::Vector2&     value) const { return (this->vector2_     == value); }
+        bool operator==(const orxonox::Vector3&     value) const { return (this->vector3_     == value); }
+        bool operator==(const orxonox::ColourValue& value) const { return (this->colourvalue_ == value); }
+        bool operator==(const orxonox::Quaternion&  value) const { return (this->quaternion_  == value); }
+        bool operator==(const orxonox::Radian&      value) const { return (this->radian_      == value); }
+        bool operator==(const orxonox::Degree&      value) const { return (this->degree_      == value); }
+        bool operator==(const MultiTypeMath& mtm) const;
+
+        bool operator!=(const orxonox::Vector2&     value) const { return (this->vector2_     != value); }
+        bool operator!=(const orxonox::Vector3&     value) const { return (this->vector3_     != value); }
+        bool operator!=(const orxonox::ColourValue& value) const { return (this->colourvalue_ != value); }
+        bool operator!=(const orxonox::Quaternion&  value) const { return (this->quaternion_  != value); }
+        bool operator!=(const orxonox::Radian&      value) const { return (this->radian_      != value); }
+        bool operator!=(const orxonox::Degree&      value) const { return (this->degree_      != value); }
+        bool operator!=(const MultiTypeMath& mtm) const;
+
+        inline void setValue(const orxonox::Vector2&     value) { this->type_ = MT_vector2;     this->vector2_     = value; }
+        inline void setValue(const orxonox::Vector3&     value) { this->type_ = MT_vector3;     this->vector3_     = value; }
+        inline void setValue(const orxonox::ColourValue& value) { this->type_ = MT_colourvalue; this->colourvalue_ = value; }
+        inline void setValue(const orxonox::Quaternion&  value) { this->type_ = MT_quaternion;  this->quaternion_  = value; }
+        inline void setValue(const orxonox::Radian&      value) { this->type_ = MT_radian;      this->radian_      = value; }
+        inline void setValue(const orxonox::Degree&      value) { this->type_ = MT_degree;      this->degree_      = value; }
+        void setValue(const MultiTypeMath& mtm);
+
+        inline orxonox::Vector2&     getVector2()     { return this->vector2_;     }
+        inline orxonox::Vector3&     getVector3()     { return this->vector3_;     }
+        inline orxonox::ColourValue& getColourValue() { return this->colourvalue_; }
+        inline orxonox::Quaternion&  getQuaternion()  { return this->quaternion_;  }
+        inline orxonox::Radian&      getRadian()      { return this->radian_;      }
+        inline orxonox::Degree&      getDegree()      { return this->degree_;      }
+
+        inline void getValue(orxonox::Vector2*     variable) const { (*variable) = orxonox::Vector2     (this->vector2_);     }
+        inline void getValue(orxonox::Vector3*     variable) const { (*variable) = orxonox::Vector3     (this->vector3_);     }
+        inline void getValue(orxonox::ColourValue* variable) const { (*variable) = orxonox::ColourValue (this->colourvalue_); }
+        inline void getValue(orxonox::Quaternion*  variable) const { (*variable) = orxonox::Quaternion  (this->quaternion_);  }
+        inline void getValue(orxonox::Radian*      variable) const { (*variable) = orxonox::Radian      (this->radian_);      }
+        inline void getValue(orxonox::Degree*      variable) const { (*variable) = orxonox::Degree      (this->degree_);      }
+
+    protected:
+        orxonox::Vector2      vector2_;
+        orxonox::Vector3      vector3_;
+        orxonox::ColourValue  colourvalue_;
+        orxonox::Quaternion   quaternion_;
+        orxonox::Radian       radian_;
+        orxonox::Degree       degree_;
+};
+
+#endif /* _MultiTypeMath_H__ */
Index: code/branches/core/src/util/MultiTypePrimitive.cc
===================================================================
--- code/branches/core/src/util/MultiTypePrimitive.cc	(revision 792)
+++ code/branches/core/src/util/MultiTypePrimitive.cc	(revision 792)
@@ -0,0 +1,146 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Fabian 'x3n' Landau
+ *   Co-authors:
+ *      ...
+ *
+ *   Inspiration: MultiType by Benjamin Grauer
+ */
+
+#include "MultiTypePrimitive.h"
+
+MultiTypePrimitive::MultiTypePrimitive(MultiType type)
+{
+    this->type_ = type;
+
+    if (type == MT_int)
+        this->value_.int_ = 0;
+    else if (type == MT_uint)
+        this->value_.uint_ = 0;
+    else if (type == MT_char)
+        this->value_.char_ = 0;
+    else if (type == MT_uchar)
+        this->value_.uchar_ = 0;
+    else if (type == MT_short)
+        this->value_.short_ = 0;
+    else if (type == MT_ushort)
+        this->value_.ushort_ = 0;
+    else if (type == MT_long)
+        this->value_.long_ = 0;
+    else if (type == MT_ulong)
+        this->value_.ulong_ = 0;
+    else if (type == MT_float)
+        this->value_.float_ = 0.0;
+    else if (type == MT_double)
+        this->value_.double_ = 0.0;
+    else if (type == MT_longdouble)
+        this->value_.longdouble_ = 0.0;
+    else if (type == MT_bool)
+        this->value_.bool_ = false;
+    else
+        this->value_.int_ = 0;
+}
+
+MultiTypePrimitive::MultiTypePrimitive(const MultiTypePrimitive& mtp)
+{
+    this->type_ = mtp.type_;
+    this->value_ = mtp.value_;
+}
+
+MultiTypePrimitive& MultiTypePrimitive::operator=(const MultiTypePrimitive& mtp)
+{
+    this->type_ = mtp.type_;
+    this->value_ = mtp.value_;
+    return *this;
+}
+
+bool MultiTypePrimitive::operator==(const MultiTypePrimitive& mtp) const
+{
+    if (this->type_ == mtp.type_)
+    {
+        if (this->type_ == MT_int)
+            return (this->value_.int_ == mtp.value_.int_);
+        else if (this->type_ == MT_uint)
+            return (this->value_.uint_ == mtp.value_.uint_);
+        else if (this->type_ == MT_char)
+            return (this->value_.char_ == mtp.value_.char_);
+        else if (this->type_ == MT_uchar)
+            return (this->value_.uchar_ == mtp.value_.uchar_);
+        else if (this->type_ == MT_short)
+            return (this->value_.short_ == mtp.value_.short_);
+        else if (this->type_ == MT_ushort)
+            return (this->value_.ushort_ == mtp.value_.ushort_);
+        else if (this->type_ == MT_long)
+            return (this->value_.long_ == mtp.value_.long_);
+        else if (this->type_ == MT_ulong)
+            return (this->value_.ulong_ == mtp.value_.ulong_);
+        else if (this->type_ == MT_float)
+            return (this->value_.float_ == mtp.value_.float_);
+        else if (this->type_ == MT_double)
+            return (this->value_.double_ == mtp.value_.double_);
+        else if (this->type_ == MT_longdouble)
+            return (this->value_.longdouble_ == mtp.value_.longdouble_);
+        else if (this->type_ == MT_bool)
+            return (this->value_.bool_ == mtp.value_.bool_);
+    }
+
+    return false;
+}
+
+bool MultiTypePrimitive::operator!=(const MultiTypePrimitive& mtp) const
+{
+    if (this->type_ == mtp.type_)
+    {
+        if (this->type_ == MT_int)
+            return (this->value_.int_ != mtp.value_.int_);
+        else if (this->type_ == MT_uint)
+            return (this->value_.uint_ != mtp.value_.uint_);
+        else if (this->type_ == MT_char)
+            return (this->value_.char_ != mtp.value_.char_);
+        else if (this->type_ == MT_uchar)
+            return (this->value_.uchar_ != mtp.value_.uchar_);
+        else if (this->type_ == MT_short)
+            return (this->value_.short_ != mtp.value_.short_);
+        else if (this->type_ == MT_ushort)
+            return (this->value_.ushort_ != mtp.value_.ushort_);
+        else if (this->type_ == MT_long)
+            return (this->value_.long_ != mtp.value_.long_);
+        else if (this->type_ == MT_ulong)
+            return (this->value_.ulong_ != mtp.value_.ulong_);
+        else if (this->type_ == MT_float)
+            return (this->value_.float_ != mtp.value_.float_);
+        else if (this->type_ == MT_double)
+            return (this->value_.double_ != mtp.value_.double_);
+        else if (this->type_ == MT_longdouble)
+            return (this->value_.longdouble_ != mtp.value_.longdouble_);
+        else if (this->type_ == MT_bool)
+            return (this->value_.bool_ != mtp.value_.bool_);
+    }
+
+    return true;
+}
+
+void MultiTypePrimitive::setValue(const MultiTypePrimitive& mtp)
+{
+    this->type_ = mtp.type_;
+    this->value_ = mtp.value_;
+}
Index: code/branches/core/src/util/MultiTypePrimitive.h
===================================================================
--- code/branches/core/src/util/MultiTypePrimitive.h	(revision 792)
+++ code/branches/core/src/util/MultiTypePrimitive.h	(revision 792)
@@ -0,0 +1,144 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Fabian 'x3n' Landau
+ *   Co-authors:
+ *      ...
+ *
+ *   Inspiration: MultiType by Benjamin Grauer
+ */
+
+#ifndef _MultiTypePrimitive_H__
+#define _MultiTypePrimitive_H__
+
+#include "UtilPrereqs.h"
+
+#include "MultiType.h"
+
+class _UtilExport MultiTypePrimitive
+{
+    public:
+        MultiTypePrimitive(MultiType      type = MT_null);
+        MultiTypePrimitive(int            value) { this->setValue(value); }
+        MultiTypePrimitive(unsigned int   value) { this->setValue(value); }
+        MultiTypePrimitive(char           value) { this->setValue(value); }
+        MultiTypePrimitive(unsigned char  value) { this->setValue(value); }
+        MultiTypePrimitive(short          value) { this->setValue(value); }
+        MultiTypePrimitive(unsigned short value) { this->setValue(value); }
+        MultiTypePrimitive(long           value) { this->setValue(value); }
+        MultiTypePrimitive(unsigned long  value) { this->setValue(value); }
+        MultiTypePrimitive(float          value) { this->setValue(value); }
+        MultiTypePrimitive(double         value) { this->setValue(value); }
+        MultiTypePrimitive(long double    value) { this->setValue(value); }
+        MultiTypePrimitive(bool           value) { this->setValue(value); }
+        MultiTypePrimitive(const MultiTypePrimitive& mtp);
+
+        MultiTypePrimitive& operator=(int            value) { this->setValue(value); return *this; }
+        MultiTypePrimitive& operator=(unsigned int   value) { this->setValue(value); return *this; }
+        MultiTypePrimitive& operator=(char           value) { this->setValue(value); return *this; }
+        MultiTypePrimitive& operator=(unsigned char  value) { this->setValue(value); return *this; }
+        MultiTypePrimitive& operator=(short          value) { this->setValue(value); return *this; }
+        MultiTypePrimitive& operator=(unsigned short value) { this->setValue(value); return *this; }
+        MultiTypePrimitive& operator=(long           value) { this->setValue(value); return *this; }
+        MultiTypePrimitive& operator=(unsigned long  value) { this->setValue(value); return *this; }
+        MultiTypePrimitive& operator=(float          value) { this->setValue(value); return *this; }
+        MultiTypePrimitive& operator=(double         value) { this->setValue(value); return *this; }
+        MultiTypePrimitive& operator=(long double    value) { this->setValue(value); return *this; }
+        MultiTypePrimitive& operator=(bool           value) { this->setValue(value); return *this; }
+        MultiTypePrimitive& operator=(const MultiTypePrimitive& mtp);
+
+        bool operator==(int            value) const { return (this->value_.int_        == value); }
+        bool operator==(unsigned int   value) const { return (this->value_.uint_       == value); }
+        bool operator==(char           value) const { return (this->value_.char_       == value); }
+        bool operator==(unsigned char  value) const { return (this->value_.uchar_      == value); }
+        bool operator==(short          value) const { return (this->value_.short_      == value); }
+        bool operator==(unsigned short value) const { return (this->value_.ushort_     == value); }
+        bool operator==(long           value) const { return (this->value_.long_       == value); }
+        bool operator==(unsigned long  value) const { return (this->value_.ulong_      == value); }
+        bool operator==(float          value) const { return (this->value_.float_      == value); }
+        bool operator==(double         value) const { return (this->value_.double_     == value); }
+        bool operator==(long double    value) const { return (this->value_.longdouble_ == value); }
+        bool operator==(bool           value) const { return (this->value_.bool_       == value); }
+        bool operator==(const MultiTypePrimitive& mtp) const;
+
+        bool operator!=(int            value) const { return (this->value_.int_        != value); }
+        bool operator!=(unsigned int   value) const { return (this->value_.uint_       != value); }
+        bool operator!=(char           value) const { return (this->value_.char_       != value); }
+        bool operator!=(unsigned char  value) const { return (this->value_.uchar_      != value); }
+        bool operator!=(short          value) const { return (this->value_.short_      != value); }
+        bool operator!=(unsigned short value) const { return (this->value_.ushort_     != value); }
+        bool operator!=(long           value) const { return (this->value_.long_       != value); }
+        bool operator!=(unsigned long  value) const { return (this->value_.ulong_      != value); }
+        bool operator!=(float          value) const { return (this->value_.float_      != value); }
+        bool operator!=(double         value) const { return (this->value_.double_     != value); }
+        bool operator!=(long double    value) const { return (this->value_.longdouble_ != value); }
+        bool operator!=(bool           value) const { return (this->value_.bool_       != value); }
+        bool operator!=(const MultiTypePrimitive& mtp) const;
+
+        inline void setValue(int            value) { this->type_ = MT_int;        this->value_.int_        = value; }
+        inline void setValue(unsigned int   value) { this->type_ = MT_uint;       this->value_.uint_       = value; }
+        inline void setValue(char           value) { this->type_ = MT_char;       this->value_.char_       = value; }
+        inline void setValue(unsigned char  value) { this->type_ = MT_uchar;      this->value_.uchar_      = value; }
+        inline void setValue(short          value) { this->type_ = MT_short;      this->value_.short_      = value; }
+        inline void setValue(unsigned short value) { this->type_ = MT_ushort;     this->value_.ushort_     = value; }
+        inline void setValue(long           value) { this->type_ = MT_long;       this->value_.long_       = value; }
+        inline void setValue(unsigned long  value) { this->type_ = MT_ulong;      this->value_.ulong_      = value; }
+        inline void setValue(float          value) { this->type_ = MT_float;      this->value_.float_      = value; }
+        inline void setValue(double         value) { this->type_ = MT_double;     this->value_.double_     = value; }
+        inline void setValue(long double    value) { this->type_ = MT_longdouble; this->value_.longdouble_ = value; }
+        inline void setValue(bool           value) { this->type_ = MT_bool;       this->value_.bool_       = value; }
+        void setValue(const MultiTypePrimitive& mtp);
+
+        inline int            getInt()           const { return this->value_.int_;        }
+        inline unsigned int   getUnsignedInt()   const { return this->value_.uint_;       }
+        inline char           getChar()          const { return this->value_.char_;       }
+        inline unsigned char  getUnsignedChar()  const { return this->value_.uchar_;      }
+        inline short          getShort()         const { return this->value_.short_;      }
+        inline unsigned short getUnsignedShort() const { return this->value_.ushort_;     }
+        inline long           getLong()          const { return this->value_.long_;       }
+        inline unsigned long  getUnsignedLong()  const { return this->value_.ulong_;      }
+        inline float          getFloat()         const { return this->value_.float_;      }
+        inline double         getDouble()        const { return this->value_.double_;     }
+        inline long double    getLongDouble()    const { return this->value_.longdouble_; }
+        inline bool           getBool()          const { return this->value_.bool_;       }
+
+        inline void getValue(int*            variable) const { (*variable) = this->value_.int_;        }
+        inline void getValue(unsigned int*   variable) const { (*variable) = this->value_.uint_;       }
+        inline void getValue(char*           variable) const { (*variable) = this->value_.char_;       }
+        inline void getValue(unsigned char*  variable) const { (*variable) = this->value_.uchar_;      }
+        inline void getValue(short*          variable) const { (*variable) = this->value_.short_;      }
+        inline void getValue(unsigned short* variable) const { (*variable) = this->value_.ushort_;     }
+        inline void getValue(long*           variable) const { (*variable) = this->value_.long_;       }
+        inline void getValue(unsigned long*  variable) const { (*variable) = this->value_.ulong_;      }
+        inline void getValue(float*          variable) const { (*variable) = this->value_.float_;      }
+        inline void getValue(double*         variable) const { (*variable) = this->value_.double_;     }
+        inline void getValue(long double*    variable) const { (*variable) = this->value_.longdouble_; }
+        inline void getValue(bool*           variable) const { (*variable) = this->value_.bool_;       }
+
+        inline MultiType getType()           const { return this->type_; }
+        inline bool      isA(MultiType type) const { return (this->type_ == type); }
+
+    protected:
+        MultiTypeValue  value_;
+        MultiType       type_;
+};
+
+#endif /* _MultiTypePrimitive_H__ */
Index: code/branches/core/src/util/MultiTypeString.cc
===================================================================
--- code/branches/core/src/util/MultiTypeString.cc	(revision 792)
+++ code/branches/core/src/util/MultiTypeString.cc	(revision 792)
@@ -0,0 +1,82 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Fabian 'x3n' Landau
+ *   Co-authors:
+ *      ...
+ *
+ *   Inspiration: MultiType by Benjamin Grauer
+ */
+
+#include "MultiTypeString.h"
+
+MultiTypeString::MultiTypeString(MultiType type) : MultiTypePrimitive(type)
+{
+    if (type == MT_constchar)
+        this->string_ = std::string("");
+    else if (type == MT_string)
+        this->string_ = std::string("");
+}
+
+MultiTypeString::MultiTypeString(const MultiTypeString& mts)
+{
+    this->type_ = mts.type_;
+    this->value_ = mts.value_;
+}
+
+MultiTypeString& MultiTypeString::operator=(const MultiTypeString& mts)
+{
+    this->type_ = mts.type_;
+    this->value_ = mts.value_;
+    return *this;
+}
+
+bool MultiTypeString::operator==(const MultiTypeString& mts) const
+{
+    if (!MultiTypePrimitive::operator==(mts) && this->type_ == mts.type_)
+    {
+        if (this->type_ == MT_constchar)
+            return (this->string_ == mts.string_);
+        else if (this->type_ == MT_string)
+            return (this->string_ == mts.string_);
+    }
+
+    return false;
+}
+
+bool MultiTypeString::operator!=(const MultiTypeString& mts) const
+{
+    if (MultiTypePrimitive::operator==(mts) && this->type_ == mts.type_)
+    {
+        if (this->type_ == MT_constchar)
+            return (this->string_ != mts.string_);
+        else if (this->type_ == MT_string)
+            return (this->string_ != mts.string_);
+    }
+
+    return true;
+}
+
+void MultiTypeString::setValue(const MultiTypeString& mts)
+{
+    this->type_ = mts.type_;
+    this->value_ = mts.value_;
+}
Index: code/branches/core/src/util/MultiTypeString.h
===================================================================
--- code/branches/core/src/util/MultiTypeString.h	(revision 792)
+++ code/branches/core/src/util/MultiTypeString.h	(revision 792)
@@ -0,0 +1,82 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Fabian 'x3n' Landau
+ *   Co-authors:
+ *      ...
+ *
+ *   Inspiration: MultiType by Benjamin Grauer
+ */
+
+#ifndef _MultiTypeString_H__
+#define _MultiTypeString_H__
+
+#include <string>
+
+#include "UtilPrereqs.h"
+
+#include "MultiTypePrimitive.h"
+
+class _UtilExport MultiTypeString : public MultiTypePrimitive
+{
+    public:
+        MultiTypeString(MultiType      type = MT_null);
+        MultiTypeString(int            value) : MultiTypePrimitive(value) {}
+        MultiTypeString(unsigned int   value) : MultiTypePrimitive(value) {}
+        MultiTypeString(char           value) : MultiTypePrimitive(value) {}
+        MultiTypeString(unsigned char  value) : MultiTypePrimitive(value) {}
+        MultiTypeString(short          value) : MultiTypePrimitive(value) {}
+        MultiTypeString(unsigned short value) : MultiTypePrimitive(value) {}
+        MultiTypeString(long           value) : MultiTypePrimitive(value) {}
+        MultiTypeString(unsigned long  value) : MultiTypePrimitive(value) {}
+        MultiTypeString(float          value) : MultiTypePrimitive(value) {}
+        MultiTypeString(double         value) : MultiTypePrimitive(value) {}
+        MultiTypeString(long double    value) : MultiTypePrimitive(value) {}
+        MultiTypeString(bool           value) : MultiTypePrimitive(value) {}
+        MultiTypeString(const char*        value) { this->setValue(value); }
+        MultiTypeString(const std::string& value) { this->setValue(value); }
+        MultiTypeString(const MultiTypeString& mtp);
+
+        MultiTypeString& operator=(const char*        value) { this->setValue(value); return *this; }
+        MultiTypeString& operator=(const std::string& value) { this->setValue(value); return *this; }
+        MultiTypeString& operator=(const MultiTypeString& mtp);
+
+        bool operator==(const char*        value) const { return (this->string_ == std::string(value)); }
+        bool operator==(const std::string& value) const { return (this->string_ == value); }
+        bool operator==(const MultiTypeString& mtp) const;
+
+        bool operator!=(const char*        value) const { return (this->string_ != std::string(value)); }
+        bool operator!=(const std::string& value) const { return (this->string_ != value); }
+        bool operator!=(const MultiTypeString& mtp) const;
+
+        inline void setValue(const char*        value) { this->type_ = MT_string; this->string_ = std::string(value); }
+        inline void setValue(const std::string& value) { this->type_ = MT_string; this->string_ = value; }
+        void setValue(const MultiTypeString& mtp);
+
+        inline std::string& getString() { return this->string_; }
+
+        inline void getValue(std::string* variable) const { (*variable) = std::string(this->string_); }
+
+    protected:
+        std::string string_;
+};
+
+#endif /* _MultiTypeString_H__ */
Index: code/branches/core/src/util/String.cc
===================================================================
--- code/branches/core/src/util/String.cc	(revision 792)
+++ code/branches/core/src/util/String.cc	(revision 792)
@@ -0,0 +1,213 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Fabian 'x3n' Landau
+ *   Co-authors:
+ *      Benjamin Grauer
+ *
+ */
+
+#include "String.h"
+
+/**
+    @brief Removes all whitespaces from a string.
+    @param str The string to strip
+*/
+void strip(std::string* str)
+{
+    unsigned int pos;
+    while ((pos = (*str).find(" ")) < (*str).length())
+        (*str).erase(pos, 1);
+    while ((pos = (*str).find("\t")) < (*str).length())
+        (*str).erase(pos, 1);
+}
+
+/**
+    @brief Returns a copy of a string without whitespaces.
+    @param str The string to strip
+    @return The stripped line
+*/
+std::string getStripped(const std::string& str)
+{
+    std::string output = std::string(str);
+    strip(&output);
+    return output;
+}
+
+/**
+    @brief Determines if a string in is a comment.
+    @param str The string to check
+    @return True = it's a comment
+
+    A comment is defined by a leading '#', '%', ';' or '//'.
+*/
+bool isComment(const std::string& str)
+{
+    // Strip the line, whitespaces are disturbing
+    std::string teststring = getStripped(str);
+
+    // There are four possible comment-symbols:
+    //  1) #comment in script-language style
+    //  2) %comment in matlab style
+    //  3) ;comment in unreal tournament config-file style
+    //  4) //comment in code style
+    if (teststring[0] == '#' || teststring[0] == '%' || teststring[0] == ';' || (teststring[0] == '/' && teststring[0] == '/'))
+        return true;
+
+    return false;
+}
+
+/**
+    @brief Determines if a string is empty (contains only whitespaces).
+    @param str The string to check
+    @return True = it's empty
+*/
+bool isEmpty(const std::string& str)
+{
+    return getStripped(str) == "";
+}
+
+/**
+    @brief Determines if a string contains only numbers and maximal one '.'.
+    @param str The string to check
+    @return True = it's a number
+*/
+bool isNumeric(const std::string& str)
+{
+    bool foundPoint = false;
+
+    for (std::string::const_iterator it = str.begin(); it != str.end(); ++it)
+    {
+        if (((*it) < '0' || (*it) > '9'))
+        {
+            if ((*it) != '.' && !foundPoint)
+                foundPoint = true;
+            else
+                return false;
+        }
+    }
+
+    return true;
+}
+
+/**
+    @brief Replaces each char between A and Z with its lowercase equivalent.
+    @param str The string to convert
+*/
+void lowercase(std::string* str)
+{
+    static unsigned const char difference_between_A_and_a = 'A' - 'a';
+
+    for (std::string::iterator it = (*str).begin(); it != (*str).end(); ++it)
+        if ((*it) >= 'A' && (*it) <= 'Z')
+            (*it) -= difference_between_A_and_a;
+}
+
+/**
+    @brief Returns a copy of the given string without uppercase chars.
+    @param str The string
+    @return The copy
+*/
+std::string getLowercase(const std::string& str)
+{
+    std::string output = std::string(str);
+    lowercase(&output);
+    return output;
+}
+
+/**
+    @brief Replaces each char between a and z with its uppercase equivalent.
+    @param str The string to convert
+*/
+void uppercase(std::string* str)
+{
+    static unsigned const char difference_between_A_and_a = 'A' - 'a';
+
+    for (std::string::iterator it = (*str).begin(); it != (*str).end(); ++it)
+        if ((*it) >= 'a' && (*it) <= 'z')
+            (*it) += difference_between_A_and_a;
+}
+
+/**
+    @brief Returns a copy of the given string without lowercase chars.
+    @param str The string
+    @return The copy
+*/
+std::string getUppercase(const std::string& str)
+{
+    std::string output = std::string(str);
+    uppercase(&output);
+    return output;
+}
+
+/**
+ * @brief compares two strings without ignoring the case
+ * @param s1 first string
+ * @param s2 second string
+ */
+int nocaseCmp(const std::string& s1, const std::string& s2)
+{
+    std::string::const_iterator it1=s1.begin();
+    std::string::const_iterator it2=s2.begin();
+
+    //stop when either string's end has been reached
+    while ( (it1!=s1.end()) && (it2!=s2.end()) )
+    {
+        if(::toupper(*it1) != ::toupper(*it2)) //letters differ?
+            // return -1 to indicate smaller than, 1 otherwise
+            return (::toupper(*it1)  < ::toupper(*it2)) ? -1 : 1;
+        //proceed to the next character in each string
+        ++it1;
+        ++it2;
+    }
+    size_t size1=s1.size(), size2=s2.size();// cache lengths
+    //return -1,0 or 1 according to strings' lengths
+    if (size1==size2)
+        return 0;
+    return (size1<size2) ? -1 : 1;
+}
+
+
+/**
+ * @brief compares two strings without ignoring the case
+ * @param s1 first string
+ * @param s2 second string
+ * @param len how far from the beginning to start.
+ */
+int nocaseCmp(const std::string& s1, const std::string& s2, unsigned int len)
+{
+    if (len == 0)
+        return 0;
+    std::string::const_iterator it1=s1.begin();
+    std::string::const_iterator it2=s2.begin();
+
+    //stop when either string's end has been reached
+    while ( (it1!=s1.end()) && (it2!=s2.end()) && len-- > 0)
+    {
+        if(::toupper(*it1) != ::toupper(*it2)) //letters differ?
+            // return -1 to indicate smaller than, 1 otherwise
+            return (::toupper(*it1)  < ::toupper(*it2)) ? -1 : 1;
+        //proceed to the next character in each string
+        ++it1;
+        ++it2;
+    }
+    return 0;
+}
Index: code/branches/core/src/util/String.h
===================================================================
--- code/branches/core/src/util/String.h	(revision 792)
+++ code/branches/core/src/util/String.h	(revision 792)
@@ -0,0 +1,146 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Fabian 'x3n' Landau
+ *   Co-authors:
+ *      Benjamin Grauer
+ *
+ */
+
+#ifndef _String_H__
+#define _String_H__
+
+#include <string>
+#include <sstream>
+
+#include "UtilPrereqs.h"
+
+_UtilExport void        strip(std::string* str);
+_UtilExport std::string getStripped(const std::string& str);
+
+_UtilExport bool        isEmpty(const std::string& str);
+_UtilExport bool        isComment(const std::string& str);
+_UtilExport bool        isNumeric(const std::string& str);
+
+_UtilExport void        lowercase(std::string* str);
+_UtilExport std::string getLowercase(const std::string& str);
+
+_UtilExport void        uppercase(std::string* str);
+_UtilExport std::string getUppercase(const std::string& str);
+
+_UtilExport int         nocaseCmp(const std::string& s1, const std::string& s2);
+_UtilExport int         nocaseCmp(const std::string& s1, const std::string& s2, unsigned int len);
+
+//! The Convert class has some static member functions to convert strings to values and values to strings.
+class _UtilExport Convert
+{
+    public:
+        /**
+            @brief Converts a value of any type to a string.
+            @param output The string to write the result in
+            @param input The variable to convert
+            @return True if the conversion succeded
+
+            @example
+            float f = 3.14;
+            std::string output;
+            bool success = Convert::ToString(output, f);
+        */
+        template <typename T>
+        static bool ToString(std::string* output, T input)
+        {
+            std::ostringstream oss;
+            if (oss << input)
+            {
+                (*output) = oss.str();
+                return true;
+            }
+
+            return false;
+        }
+
+        /**
+            @brief Converts a value of any type to a string and assigns a defaultvalue if the conversion fails.
+            @param output The string to write the result in
+            @param input The variable to convert
+            @param fallbackString The assigned string if the conversion fails.
+            @return True if the conversion succeeded
+
+            @example
+            float f = 3.14;
+            std::string output;
+            bool success = Convert::ToString(output, f, "0.000000");
+        */
+        template <typename T>
+        static bool ToString(std::string* output, T input, const std::string& fallbackString)
+        {
+            if (Convert::ToString(output, input))
+                return true;
+
+            (*output) = fallbackString;
+            return false;
+        }
+
+        /**
+            @brief Converts a string to a value of any type.
+            @param output The variable to assign the result to
+            @param input The string to convert
+            @return True if the conversion succeeded
+
+            @example
+            std::string input = "3.14";
+            float f;
+            bool success = string2Number(f, input);
+        */
+        template <typename T>
+        static bool FromString(T* output, const std::string& input)
+        {
+            std::istringstream iss(input);
+            if (iss >> (*output))
+                return true;
+
+            return false;
+        }
+
+        /**
+            @brief Converts a string to a value of any type.
+            @param output The variable to assign the result to
+            @param input The string to convert
+            @param fallbackValue The assigned value if the conversion fails
+            @return True if the conversion succeeded
+
+            @example
+            std::string input = "3.14";
+            float f;
+            bool success = string2Number(f, input, 0.000000);
+        */
+        template <typename T>
+        static bool FromString(T* output, const std::string& input, T fallbackValue)
+        {
+            if (Convert::FromString(output, input))
+                return true;
+
+            (*output) = fallbackValue;
+            return false;
+        }
+};
+
+#endif /* _String_H__ */
Index: code/branches/core/src/util/String2Number.h
===================================================================
--- code/branches/core/src/util/String2Number.h	(revision 791)
+++ code/branches/core/src/util/String2Number.h	(revision 792)
@@ -7,4 +7,5 @@
 
 #include "core/Debug.h"
+#include "UtilPrereqs.h"
 
 /**
@@ -23,5 +24,5 @@
 
 template <class T>
-class String2Number
+class _UtilExport String2Number
 {
   private:
Index: code/branches/core/src/util/UtilPrereqs.h
===================================================================
--- code/branches/core/src/util/UtilPrereqs.h	(revision 792)
+++ code/branches/core/src/util/UtilPrereqs.h	(revision 792)
@@ -0,0 +1,71 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Reto Grieder
+ *   Co-authors:
+ *      Fabian 'x3n' Landau
+ *
+ */
+
+/**
+ @file  UtilPrereq.h
+ @brief Contains all the necessary forward declarations for all classes, structs and enums.
+ */
+
+#ifndef _UtilPrereqs_H__
+#define _UtilPrereqs_H__
+
+#include "orxonox/OrxonoxPlatform.h"
+
+//-----------------------------------------------------------------------
+// Shared library settings
+//-----------------------------------------------------------------------
+#if (ORXONOX_PLATFORM == ORXONOX_PLATFORM_WIN32) && !defined( UTIL_STATIC_BUILD )
+#  ifdef UTIL_SHARED_BUILD
+#    define _UtilExport __declspec(dllexport)
+#  else
+#    if defined( __MINGW32__ )
+#      define _UtilExport
+#    else
+#      define _UtilExport __declspec(dllimport)
+#    endif
+#  endif
+#elif defined ( ORXONOX_GCC_VISIBILITY )
+#  define _UtilExport  __attribute__ ((visibility("default")))
+#else
+#  define _UtilExport
+#endif
+
+
+//-----------------------------------------------------------------------
+// Forward declarations
+//-----------------------------------------------------------------------
+class Convert;
+template <typename FromType, typename ToType>
+class Converter;
+class MultiTypePrimitive;
+class MultiTypeString;
+class MultiTypeMath;
+template <class T>
+class String2Number;
+class SubString;
+
+#endif /* _UtilPrereqs_H__ */
Index: code/branches/core/src/util/substring.h
===================================================================
--- code/branches/core/src/util/substring.h	(revision 791)
+++ code/branches/core/src/util/substring.h	(revision 792)
@@ -59,4 +59,5 @@
 #include <string>
 
+#include "UtilPrereqs.h"
 
 //! A class that can load one string and split it in multipe ones
@@ -65,5 +66,5 @@
  * It can be used, to Split strings append them and join them again.
  */
-class SubString
+class _UtilExport SubString
 {
 public:
