Index: branches/std/src/lib/coord/p_node.cc
===================================================================
--- branches/std/src/lib/coord/p_node.cc	(revision 7215)
+++ branches/std/src/lib/coord/p_node.cc	(revision 7216)
@@ -540,5 +540,5 @@
  * @param childName the name of the child to add to this PNode
  */
-void PNode::addChild (const char* childName)
+void PNode::addChild (const std::string& childName)
 {
   PNode* childNode = dynamic_cast<PNode*>(ClassList::getObject(childName, CL_PARENT_NODE));
@@ -624,5 +624,5 @@
  * @param parentName the name of the Parent to set to this PNode
  */
-void PNode::setParent (const char* parentName)
+void PNode::setParent (const std::string& parentName)
 {
   PNode* parentNode = dynamic_cast<PNode*>(ClassList::getObject(parentName, CL_PARENT_NODE));
@@ -631,5 +631,5 @@
   else
     PRINTF(2)("Not Found PNode's (%s::%s) new Parent by Name: %s\n",
-              this->getClassName(), this->getName(), parentName);
+        this->getClassName(), this->getName(), parentName.c_str());
 }
 
@@ -699,5 +699,5 @@
  * @param parentMode a String representing this parentingMode
  */
-void PNode::setParentMode (const char* parentingMode)
+void PNode::setParentMode (const std::string& parentingMode)
 {
   this->setParentMode(PNode::charToParentingMode(parentingMode));
@@ -1068,15 +1068,15 @@
  * @return the int corresponding to the named parentingMode
  */
-PARENT_MODE PNode::charToParentingMode(const char* parentingMode)
-{
-  if (!strcmp(parentingMode, "local-rotate"))
+PARENT_MODE PNode::charToParentingMode(const std::string& parentingMode)
+{
+  if (parentingMode == "local-rotate")
     return (PNODE_LOCAL_ROTATE);
-  else  if (!strcmp(parentingMode, "rotate-movement"))
+  else  if (parentingMode == "rotate-movement")
     return (PNODE_ROTATE_MOVEMENT);
-  else  if (!strcmp(parentingMode, "movement"))
+  else  if (parentingMode == "movement")
     return (PNODE_MOVEMENT);
-  else  if (!strcmp(parentingMode, "all"))
+  else  if (parentingMode == "all")
     return (PNODE_ALL);
-  else  if (!strcmp(parentingMode, "rotate-and-move"))
+  else  if (parentingMode == "rotate-and-move")
     return (PNODE_ROTATE_AND_MOVE);
 }
Index: branches/std/src/lib/coord/p_node.h
===================================================================
--- branches/std/src/lib/coord/p_node.h	(revision 7215)
+++ branches/std/src/lib/coord/p_node.h	(revision 7216)
@@ -143,5 +143,5 @@
   // PARENTING //
   void addChild (PNode* child);
-  void addChild (const char* childName);
+  void addChild (const std::string& childName);
   void removeChild (PNode* child);
   void removeNode();
@@ -151,5 +151,5 @@
   /** @param parent the new parent of this node */
   inline void setParent (PNode* parent) { parent->addChild(this); };
-  void setParent (const char* parentName);
+  void setParent (const std::string& parentName);
   /** @returns the parent of this PNode */
   inline PNode* getParent () const { return this->parent; };
@@ -162,5 +162,5 @@
   // PARENTING_MODE AND OTHER FLAGS //
   void setParentMode (PARENT_MODE parentMode);
-  void setParentMode (const char* parentingMode);
+  void setParentMode (const std::string& parentingMode);
   /** @returns the Parenting mode of this node */
   int getParentMode() const { return 0x000f & this->parentMode; };
@@ -184,5 +184,5 @@
   // HELPER_FUNCTIONS //
   static const char* parentingModeToChar(int parentingMode);
-  static PARENT_MODE charToParentingMode(const char* parentingMode);
+  static PARENT_MODE charToParentingMode(const std::string& parentingMode);
   float distance(const PNode* node) const { return (this->getAbsCoor() - node->getAbsCoor()).len(); };
 
Index: branches/std/src/lib/graphics/effects/fog_effect.cc
===================================================================
--- branches/std/src/lib/graphics/effects/fog_effect.cc	(revision 7215)
+++ branches/std/src/lib/graphics/effects/fog_effect.cc	(revision 7216)
@@ -126,11 +126,11 @@
  * @param mode the mode character
  */
-GLint FogEffect::charToFogMode(const char* mode)
+GLint FogEffect::stringToFogMode(const std::string& mode)
 {
-  if( !strcmp( "GL_LINEAR", mode))
+  if(mode == "GL_LINEAR")
     return GL_LINEAR;
-  else if( !strcmp("GL_EXP", mode))
+  else if(mode == "GL_EXP")
     return GL_EXP;
-  else if(!strcmp("GL_EXP2", mode) )
+  else if(mode == "GL_EXP2" )
     return GL_EXP2;
   else
Index: branches/std/src/lib/graphics/effects/fog_effect.h
===================================================================
--- branches/std/src/lib/graphics/effects/fog_effect.h	(revision 7215)
+++ branches/std/src/lib/graphics/effects/fog_effect.h	(revision 7216)
@@ -26,5 +26,5 @@
     virtual bool deactivate();
 
-    inline void setFogMode(const char* mode) { this->fogMode = this->charToFogMode(mode); }
+    inline void setFogMode(const std::string& mode) { this->fogMode = this->stringToFogMode(mode); }
     inline void setFogDensity(float density) { this->fogDensity = density; }
     inline void setFogRange(float start, float end) { this->fogStart = start; this->fogEnd = end; }
@@ -33,5 +33,5 @@
 
   private:
-    GLint charToFogMode(const char* mode);
+    GLint stringToFogMode(const std::string& mode);
 
 
Index: branches/std/src/lib/graphics/effects/lense_flare.cc
===================================================================
--- branches/std/src/lib/graphics/effects/lense_flare.cc	(revision 7215)
+++ branches/std/src/lib/graphics/effects/lense_flare.cc	(revision 7216)
@@ -147,5 +147,5 @@
  *  7th: Texture of the third burst
  */
-void LenseFlare::addFlare(const char* textureName)
+void LenseFlare::addFlare(const std::string& textureName)
 {
   if( this->flares.size() > LF_MAX_FLARES)
@@ -159,5 +159,5 @@
   bb->setSize(50, 50);
   this->flares.push_back(bb);
-  PRINTF(0)("Added a Lenseflare Billboard with texture %s\n", textureName);
+  PRINTF(4)("Added a Lenseflare Billboard with texture %s\n", textureName.c_str());
 
   // the first flare belongs to the light source
@@ -167,5 +167,5 @@
     bb->setVisibility(true);
   }
-  PRINTF(0)("Finished adding\n", textureName);
+  PRINTF(4)("Finished adding\n");
 }
 
Index: branches/std/src/lib/graphics/effects/lense_flare.h
===================================================================
--- branches/std/src/lib/graphics/effects/lense_flare.h	(revision 7215)
+++ branches/std/src/lib/graphics/effects/lense_flare.h	(revision 7216)
@@ -39,5 +39,5 @@
     virtual void tick(float dt);
 
-    void addFlare(const char* textureName);
+    void addFlare(const std::string& textureName);
 
 
Index: branches/std/src/lib/graphics/render2D/billboard.cc
===================================================================
--- branches/std/src/lib/graphics/render2D/billboard.cc	(revision 7215)
+++ branches/std/src/lib/graphics/render2D/billboard.cc	(revision 7216)
@@ -78,5 +78,5 @@
 void Billboard::loadParams(const TiXmlElement* root)
 {
-  LoadParam(root, "texture", this, Billboard, setTexture)
+  LoadParam(root, "texture", this->material, Material, setDiffuseMap)
       .describe("the texture-file to load onto the Billboard");
 
@@ -100,5 +100,5 @@
  * @param textureFile The texture-file to load onto the crosshair
  */
-void Billboard::setTexture(const char* textureFile)
+void Billboard::setTexture(const std::string& textureFile)
 {
   this->material->setDiffuseMap(textureFile);
Index: branches/std/src/lib/graphics/render2D/billboard.h
===================================================================
--- branches/std/src/lib/graphics/render2D/billboard.h	(revision 7215)
+++ branches/std/src/lib/graphics/render2D/billboard.h	(revision 7216)
@@ -30,5 +30,5 @@
 
     void setSize(float sizeX, float sizeY);
-    void setTexture(const char* textureFile);
+    void setTexture(const std::string& textureFile);
     void attachTo(PNode* pnode);
 
Index: branches/std/src/lib/graphics/render2D/element_2d.cc
===================================================================
--- branches/std/src/lib/graphics/render2D/element_2d.cc	(revision 7215)
+++ branches/std/src/lib/graphics/render2D/element_2d.cc	(revision 7216)
@@ -180,13 +180,13 @@
  * @param alignment the alignment @see loadParams
 */
-void Element2D::setAlignment(const char* alignment)
-{
-  if (!strcmp(alignment, "center"))
+void Element2D::setAlignment(const std::string& alignment)
+{
+  if (alignment == "center")
     this->setAlignment(E2D_ALIGN_CENTER);
-  else if (!strcmp(alignment, "left"))
+  else if (alignment == "left")
     this->setAlignment(E2D_ALIGN_LEFT);
-  else if (!strcmp(alignment, "right"))
+  else if (alignment == "right")
     this->setAlignment(E2D_ALIGN_RIGHT);
-  else if (!strcmp(alignment, "screen-center"))
+  else if (alignment == "screen-center")
     this->setAlignment(E2D_ALIGN_SCREEN_CENTER);
 }
@@ -213,7 +213,7 @@
 /**
  * sets the layer onto which this 2D-element is projected to.
- * @param layer the layer @see loadParams @see Element2D::charToLayer2D(const char* layer)
- */
-void Element2D::setLayer(const char* layer)
+ * @param layer the layer @see loadParams @see Element2D::charToLayer2D(const std::string& layer)
+ */
+void Element2D::setLayer(const std::string& layer)
 {
   this->setLayer(Element2D::charToLayer2D(layer));
@@ -235,5 +235,5 @@
  * @param bindNode the name of the Node (should be existing)
  */
-void Element2D::setBindNode(const char* bindNode)
+void Element2D::setBindNode(const std::string& bindNode)
 {
   const PNode* tmpBindNode = dynamic_cast<const PNode*>(ClassList::getObject(bindNode, CL_PARENT_NODE));
@@ -572,5 +572,5 @@
  * @param childName the name of the child to add to this PNode
  */
-void Element2D::addChild2D (const char* childName)
+void Element2D::addChild2D (const std::string& childName)
 {
   Element2D* childNode = dynamic_cast<Element2D*>(ClassList::getObject(childName, CL_ELEMENT_2D));
@@ -651,5 +651,5 @@
  * @param parentName the name of the Parent to set to this Element2D
  */
-void Element2D::setParent2D (const char* parentName)
+void Element2D::setParent2D (const std::string& parentName)
 {
   Element2D* parentNode = dynamic_cast<Element2D*>(ClassList::getObject(parentName, CL_ELEMENT_2D));
@@ -658,5 +658,5 @@
   else
     PRINTF(2)("Not Found Element2D's (%s::%s) new Parent by Name: %s\n",
-                this->getClassName(), this->getName(), parentName);
+                this->getClassName(), this->getName(), parentName.c_str());
 }
 
@@ -704,5 +704,5 @@
  * @param bias the speed to iterate to this new Positions
  */
-void Element2D::setParentSoft2D(const char* parentName, float bias)
+void Element2D::setParentSoft2D(const std::string& parentName, float bias)
 {
   Element2D* parentNode = dynamic_cast<Element2D*>(ClassList::getObject(parentName, CL_ELEMENT_2D));
@@ -724,5 +724,5 @@
  * @param parentMode a String representing this parentingMode
  */
-void Element2D::setParentMode2D (const char* parentingMode)
+void Element2D::setParentMode2D (const std::string& parentingMode)
 {
   this->setParentMode2D(Element2D::charToParentingMode2D(parentingMode));
@@ -1093,15 +1093,15 @@
  * @return the int corresponding to the named parentingMode
  */
-E2D_PARENT_MODE Element2D::charToParentingMode2D(const char* parentingMode)
-{
-  if (!strcmp(parentingMode, "local-rotate"))
+E2D_PARENT_MODE Element2D::charToParentingMode2D(const std::string& parentingMode)
+{
+  if (parentingMode == "local-rotate")
     return (E2D_PARENT_LOCAL_ROTATE);
-  else  if (!strcmp(parentingMode, "rotate-movement"))
+  else  if (parentingMode == "rotate-movement")
     return (E2D_PARENT_ROTATE_MOVEMENT);
-  else  if (!strcmp(parentingMode, "movement"))
+  else  if (parentingMode == "movement")
     return (E2D_PARENT_MOVEMENT);
-  else  if (!strcmp(parentingMode, "all"))
+  else  if (parentingMode == "all")
     return (E2D_PARENT_ALL);
-  else  if (!strcmp(parentingMode, "rotate-and-move"))
+  else  if (parentingMode == "rotate-and-move")
     return (E2D_PARENT_ROTATE_AND_MOVE);
 }
@@ -1139,13 +1139,13 @@
  * @returns the E2D_LAYER on success, E2D_DEFAULT_LAYER on error.
  */
-E2D_LAYER Element2D::charToLayer2D(const char* layer)
-{
-  if (!strcmp(layer, "top"))
+E2D_LAYER Element2D::charToLayer2D(const std::string& layer)
+{
+  if (layer =="top")
     return (E2D_LAYER_TOP);
-  else  if (!strcmp(layer, "medium"))
+  else  if (layer == "medium")
     return (E2D_LAYER_MEDIUM);
-  else  if (!strcmp(layer, "bottom"))
+  else  if (layer == "bottom")
     return (E2D_LAYER_BOTTOM);
-  else  if (!strcmp(layer, "below-all"))
+  else  if (layer == "below-all")
     return (E2D_LAYER_BELOW_ALL);
   else
Index: branches/std/src/lib/graphics/render2D/element_2d.h
===================================================================
--- branches/std/src/lib/graphics/render2D/element_2d.h	(revision 7215)
+++ branches/std/src/lib/graphics/render2D/element_2d.h	(revision 7216)
@@ -102,10 +102,10 @@
     /** @param alignment the new Alignment of the 2D-Element */
     inline void setAlignment(E2D_ALIGNMENT alignment) { this->alignment = alignment; };
-    void setAlignment(const char* alignment);
+    void setAlignment(const std::string& alignment);
     inline E2D_ALIGNMENT getAlignment() const { return this->alignment; };
 
     // LAYERING //
     void setLayer(E2D_LAYER layer);
-    void setLayer(const char* layer);
+    void setLayer(const std::string& layer);
     /** @returns the Layer this Element is drawn to */
     inline E2D_LAYER getLayer() const { return this->layer; };
@@ -121,5 +121,5 @@
     /** @param bindNode the Node this 2D-element should follow. if NULL the Element will not follow anything */
     inline void setBindNode(const PNode* bindNode) { this->bindNode = bindNode; };
-    void setBindNode(const char* bindNode);
+    void setBindNode(const std::string& bindNode);
     inline const PNode* getBindNode() const { return this->bindNode; };
 
@@ -181,5 +181,5 @@
 
     void addChild2D (Element2D* child);
-    void addChild2D (const char* childName);
+    void addChild2D (const std::string& childName);
     void removeChild2D (Element2D* child);
     void remove2D();
@@ -187,5 +187,5 @@
     /** @param parent the new parent of this Element2D */
     void setParent2D (Element2D* parent) { parent->addChild2D(this); };
-    void setParent2D (const char* parentName);
+    void setParent2D (const std::string& parentName);
     /** @returns the parent of this Element2D */
     inline Element2D* getParent2D () const { return this->parent; };
@@ -194,8 +194,8 @@
 
     void setParentSoft2D(Element2D* parentNode, float bias = 1.0);
-    void setParentSoft2D(const char* parentName, float bias = 1.0);
+    void setParentSoft2D(const std::string& parentName, float bias = 1.0);
 
     void setParentMode2D (E2D_PARENT_MODE parentMode);
-    void setParentMode2D (const char* parentingMode);
+    void setParentMode2D (const std::string& parentingMode);
     /** @returns the Parenting mode of this node */
     int getParentMode2D() const { return this->parentMode; };
@@ -213,8 +213,8 @@
     // helper functions //
     static const char* parentingModeToChar2D(int parentingMode);
-    static E2D_PARENT_MODE charToParentingMode2D(const char* parentingMode);
+    static E2D_PARENT_MODE charToParentingMode2D(const std::string& parentingMode);
 
     static const char* layer2DToChar(E2D_LAYER layer);
-    static E2D_LAYER charToLayer2D(const char* layer);
+    static E2D_LAYER charToLayer2D(const std::string& layer);
 
   private:
Index: branches/std/src/lib/graphics/text_engine/text.cc
===================================================================
--- branches/std/src/lib/graphics/text_engine/text.cc	(revision 7215)
+++ branches/std/src/lib/graphics/text_engine/text.cc	(revision 7216)
@@ -50,7 +50,4 @@
   if (this->font != NULL && this->font != Font::getDefaultFont())
     ResourceManager::getInstance()->unload(this->font);
-
-  if (this->text)
-    delete[] this->text;
 }
 
@@ -64,11 +61,10 @@
   // initialize this Text
   this->font = NULL;
-  this->text = NULL;
-  this->externText = NULL;
+  this->text = "";
   this->setAlignment(TEXT_DEFAULT_ALIGNMENT);
   this->blending = TEXT_DEFAULT_BLENDING;
   this->color = TEXT_DEFAULT_COLOR;
   this->setSize(TEXT_DEFAULT_SIZE);
-  this->setText(NULL);
+  this->setText("");
 }
 
@@ -104,29 +100,7 @@
  * @param text the new text to set
  */
-void Text::setText(const char* text, bool isExtern)
-{
-  if (isExtern)
-  {
-    this->externText = text;
-
-    if (unlikely(this->text != NULL))
-    {
-      delete[] this->text;
-      this->text = NULL;
-    }
-  }
-  else
-  {
-    this->externText = NULL;
-    if (this->text)
-      delete[] this->text;
-    if (text != NULL)
-    {
-      this->text = new char[strlen(text)+1];
-      strcpy(this->text, text);
-    }
-    else
-      this->text = NULL;
-  }
+void Text::setText(const std::string& text)
+{
+  this->text = text;
 
   // setting up the Text-Width if DYNAMIC
@@ -138,16 +112,12 @@
 
     float width = 0;
-    const char* tmpText = this->externText;
-    if (this->externText == NULL)
-      tmpText = this->text;
-    if (tmpText != NULL)
+    if (!this->text.empty())
     {
-      while (*tmpText != '\0')
+      for (unsigned int i = 0; i < this->text.size(); i++)
       {
-        if(glyphArray[*tmpText] != NULL)
+        if(glyphArray[this->text[i]] != NULL)
         {
-          width += glyphArray[*tmpText]->advance;
+          width += glyphArray[this->text[i]]->advance;
         }
-        tmpText++;
       }
       this->setSizeX2D(width *this->getSizeY2D());
@@ -190,8 +160,5 @@
     glBindTexture(GL_TEXTURE_2D, Font::getDefaultFont()->getTexture());
   }
-  const char* tmpText = this->externText;
-  if (this->externText == NULL)
-    tmpText = this->text;
-  if (likely(tmpText != NULL))
+  if (likely(!this->text.empty()))
   {
     glTranslatef(getAbsCoor2D().x, getAbsCoor2D().y, 0);
@@ -201,7 +168,7 @@
 
     glBegin(GL_QUADS);
-    while (likely(*tmpText != '\0'))
+    for (unsigned int i = 0; i < this->text.size(); i++)
     {
-      if(likely((tmpGlyph = glyphArray[*tmpText]) != NULL))
+      if(likely((tmpGlyph = glyphArray[this->text[i]]) != NULL))
       {
         glTexCoord2f(tmpGlyph->texCoord[1], tmpGlyph->texCoord[2]);
@@ -219,5 +186,4 @@
         posX += tmpGlyph->advance * this->getSizeY2D();
       }
-      ++tmpText;
     }
     glEnd();
@@ -232,8 +198,5 @@
 void Text::debug() const
 {
-  if (this->externText == NULL)
-    PRINT(0)("=== TEXT: %s ===\n", this->text);
-  else
-    PRINT(0)("=== TEXT: %s ===\n", this->externText);
+  PRINT(0)("=== TEXT: %s ===\n", this->text.c_str());
 
   if (this->getBindNode())
Index: branches/std/src/lib/graphics/text_engine/text.h
===================================================================
--- branches/std/src/lib/graphics/text_engine/text.h	(revision 7215)
+++ branches/std/src/lib/graphics/text_engine/text.h	(revision 7216)
@@ -45,8 +45,8 @@
     void setFont(const std::string& fontFile, unsigned int renderSize);
 
-    void setText(const char* text, bool isExtern = false);
+    void setText(const std::string& text);
 
     /** @returns the String this Text displays */
-    inline const char* getText() const { return (externText == NULL)?this->text:this->externText; };
+    inline const std::string& getText() const { return this->text; };
     /** @param blending the blending intensity to set (between 0.0 and 1.0) */
     inline void setBlending(float blending) { this->blending = blending; };
@@ -69,6 +69,5 @@
     Font*             font;           //!< Font of this text
 
-    char*             text;           //!< The text to display
-    const char*       externText;     //!< the text to Display from an external Source.
+    std::string       text;           //!< The text to display
     Vector            color;          //!< The color of the font.
     float             blending;       //!< The blending intensity.
Index: branches/std/src/lib/lang/base_object.cc
===================================================================
--- branches/std/src/lib/lang/base_object.cc	(revision 7215)
+++ branches/std/src/lib/lang/base_object.cc	(revision 7216)
@@ -95,7 +95,5 @@
 void BaseObject::setName (const std::string& objectName)
 {
-  printf("TEST\n");
   this->objectName = objectName;
-  printf("TEST2\n");
 }
 
Index: branches/std/src/lib/lang/class_list.cc
===================================================================
--- branches/std/src/lib/lang/class_list.cc	(revision 7215)
+++ branches/std/src/lib/lang/class_list.cc	(revision 7216)
@@ -37,7 +37,7 @@
  *  Creates a new ClassList
 */
-ClassList::ClassList(ClassID classID, unsigned long classIDFull, const char* className)
-{
-  this->className = className;
+ClassList::ClassList(ClassID classID, unsigned long classIDFull, const std::string& className)
+  : className(className)
+{
   this->classID = classID;
   this->classIDFull = classIDFull;
@@ -56,5 +56,5 @@
 
 //! a List of all strings of all classes, that have registered so far.
-std::list<const char*> ClassList::classNames;
+std::list<std::string> ClassList::classNames;
 
 /**
@@ -67,10 +67,10 @@
  * !! Before unsing the ClassList, as it creates the ClassLits
  */
-ClassList* ClassList::addToClassList(BaseObject* objectPointer, ClassID classID, unsigned long classIDFull, const char* className)
+ClassList* ClassList::addToClassList(BaseObject* objectPointer, ClassID classID, unsigned long classIDFull, const std::string& className)
 {
   if (unlikely(classList == NULL))
     ClassList::classList = new list<ClassList>();
 
-  PRINTF(5)("subscribe a '%s'\n", className );
+  PRINTF(5)("subscribe a '%s'\n", className.c_str() );
 
   ClassList* regClass = ClassList::getClassList(classID);
@@ -113,5 +113,5 @@
  * befor it changes anything.
  */
-const std::list<const char*>* ClassList::getClassNames()
+const std::list<std::string>* ClassList::getClassNames()
 {
   if (ClassList::classNames.size() != ClassList::classList->size())
@@ -155,5 +155,5 @@
  * @return the List accessed by classID, or NULL if not found
  */
-const std::list<BaseObject*>* ClassList::getList(const char* className)
+const std::list<BaseObject*>* ClassList::getList(const std::string& className)
 {
   ClassList* fl;
@@ -191,7 +191,7 @@
  * @returns the ClassList with className as specifyer, or NULL if not
  */
-ClassList* ClassList::getClassList(const char* className)
-{
-  if (className == NULL)
+ClassList* ClassList::getClassList(const std::string& className)
+{
+  if (className.empty())
     return NULL;
   std::list<ClassList>::iterator classIT = find (classList->begin(), classList->end(), className);
@@ -207,5 +207,5 @@
  * @todo: speed this up!!
  */
-BaseObject* ClassList::getObject(const char* objectName, ClassID classID)
+BaseObject* ClassList::getObject(const std::string& objectName, ClassID classID)
 {
   if (classID != CL_NULL)
@@ -216,5 +216,5 @@
       std::list<BaseObject*>::iterator bo;
       for (bo = cl->objectList.begin(); bo != cl->objectList.end(); bo++)
-        if ((*bo)->getName() != NULL && !strcmp((*bo)->getName(), objectName))
+        if ((*bo)->getName() != NULL && objectName == (*bo)->getName())
           return (*bo);
     }
@@ -227,5 +227,5 @@
       std::list<BaseObject*>::iterator bo;
       for (bo = (*cl).objectList.begin(); bo != (*cl).objectList.end(); bo++)
-        if ((*bo)->getName() != NULL && !strcmp((*bo)->getName(), objectName))
+        if ((*bo)->getName() != NULL && objectName == (*bo)->getName())
           return (*bo);
     }
@@ -276,5 +276,5 @@
     if (object->isA((*cl).classID))
   {
-    PRINT(0)("=%s::0x%.8X=-", (*cl).className, (*cl).classID);
+    PRINT(0)("=%s::0x%.8X=-", (*cl).className.c_str(), (*cl).classID);
   }
 }
@@ -285,8 +285,10 @@
  * @return a String containing the name of the Class, NULL if the Class was not found
  */
-const char* ClassList::IDToString(ClassID classID)
-{
+const std::string& ClassList::IDToString(ClassID classID)
+{
+  static const std::string empty("");
+
   ClassList* cl = ClassList::getClassList(classID);
-  return (cl != NULL) ? cl->className : NULL;
+  return (cl != NULL) ? cl->className : empty;
 }
 
@@ -296,5 +298,5 @@
  * @return the ClassID. CL_NULL, if the class was not found.
  */
-ClassID ClassList::StringToID(const char* className)
+ClassID ClassList::StringToID(const std::string& className)
 {
   ClassList* cl = ClassList::getClassList(className);
@@ -307,10 +309,7 @@
  * @returns true on match, false otherwise
  */
-bool ClassList::operator==(const char* className)
-{
-  if (likely( className != NULL && this->className != NULL))
-    return (!strcmp(this->className, className));
-  else
-    return false;
+bool ClassList::operator==(const std::string& className)
+{
+  return (this->className == className);
 }
 
@@ -342,9 +341,9 @@
       while (pow(10, lenCount) <= (*cl).objectList.size())
         ++lenCount;
-      for (int i=0; i < 30-strlen((*cl).className) - lenCount; i++)
+      for (int i=0; i < 30-(*cl).className.size() - lenCount; i++)
         (niceString[i]) = ' ';
-      niceString[30-strlen((*cl).className) - lenCount] = '\0';
-
-      PRINT(0)("| CLASS %s::%s %d\n", (*cl).className, niceString, (*cl).objectList.size());
+      niceString[30-(*cl).className.size() - lenCount] = '\0';
+
+      PRINT(0)("| CLASS %s::%s %d\n", (*cl).className.c_str(), niceString, (*cl).objectList.size());
 
       if (debugLevel >=2 && (*cl).objectList.size() > 0)
@@ -371,5 +370,5 @@
  * @see ClassList::debug
  */
-void ClassList::debugS(const char* className, unsigned int debugLevel)
+void ClassList::debugS(const std::string& className, unsigned int debugLevel)
 {
   ClassList::debug(debugLevel, ClassList::StringToID(className));
Index: branches/std/src/lib/lang/class_list.h
===================================================================
--- branches/std/src/lib/lang/class_list.h	(revision 7215)
+++ branches/std/src/lib/lang/class_list.h	(revision 7216)
@@ -10,4 +10,5 @@
 #include "class_id.h"
 #include <list>
+#include <string>
 #ifndef NULL
 #define NULL     0    //!< NULL
@@ -32,9 +33,9 @@
 class ClassList {
   public:
-    ClassList(ClassID classID, unsigned long classIDFull, const char* className);
+    ClassList(ClassID classID, unsigned long classIDFull, const std::string& className);
     virtual ~ClassList();
 
     /* MAINTENANCE FUNCTIONS THESE ARE !!ONLY FOR BASEOBJECT !! */
-    static ClassList*                     addToClassList(BaseObject* objectPointer, ClassID classID, unsigned long classIDFull, const char* className);
+    static ClassList*                     addToClassList(BaseObject* objectPointer, ClassID classID, unsigned long classIDFull, const std::string& className);
     static void                           removeFromClassList(BaseObject* objectPointer);
 
@@ -42,7 +43,7 @@
 
     static const std::list<BaseObject*>*  getList(ClassID classID = CL_NULL);// { return (ClassList* fl = ClassList::getClassList(classID) != NULL)? &(fl->objectList) : NULL; };
-    static const std::list<BaseObject*>*  getList(const char* className); // { return (ClassList* fl = ClassList::getClassList(className) != NULL)? &(fl->objectList) : NULL;  };
-    static const std::list<const char*>*  getClassNames();
-    static BaseObject*                    getObject(const char* name, ClassID classID = CL_NULL);
+    static const std::list<BaseObject*>*  getList(const std::string& className); // { return (ClassList* fl = ClassList::getClassList(className) != NULL)? &(fl->objectList) : NULL;  };
+    static const std::list<std::string>*  getClassNames();
+    static BaseObject*                    getObject(const std::string& name, ClassID classID = CL_NULL);
     static bool                           exists(const BaseObject* object, ClassID classID = CL_NULL);
 
@@ -51,28 +52,28 @@
     static void                           whatIs(const BaseObject* object);
 
-    static const char*                    IDToString(ClassID classID = CL_NULL);
-    static ClassID                        StringToID(const char* className);
+    static const std::string&             IDToString(ClassID classID = CL_NULL);
+    static ClassID                        StringToID(const std::string& className);
     static void                           debug(unsigned int debugLevel = 0, ClassID classID = CL_NULL);
-    static void                           debugS(const char* className = NULL, unsigned int debugLevel = 0);
+    static void                           debugS(const std::string& className = "", unsigned int debugLevel = 0);
 
     inline bool                           operator==(ClassID classID) { return (this->classID == classID); };
-    bool                                  operator==(const char* className);
+    bool                                  operator==(const std::string& className);
     inline ClassID                        getLeafClassID() const { return this->classID; };
 
   private:
     static ClassList*                     getClassList(ClassID classID);
-    static ClassList*                     getClassList(const char* className);
+    static ClassList*                     getClassList(const std::string& className);
 
   private:
-    ClassID                         classID;                //!< ClassID stored in this ClassList
-    unsigned long                   classIDFull;            //!< The Full ClassID of this Class.
+    ClassID                               classID;                //!< ClassID stored in this ClassList
+    unsigned long                         classIDFull;            //!< The Full ClassID of this Class.
 
-    const char*                     className;              //!< Name of the Class Stored here
+    const std::string                     className;              //!< Name of the Class Stored here
 
-    std::list<BaseObject*>          objectList;             //!< A list of Objects belonging to this Class
+    std::list<BaseObject*>                objectList;             //!< A list of Objects belonging to this Class
 
     // STATIC MEMBERS
-    static std::list<ClassList>*    classList;              //!< The first Class in the List
-    static std::list<const char*>   classNames;             //!< a List of all Names of all classes, that have registered so far.
+    static std::list<ClassList>*          classList;              //!< The first Class in the List
+    static std::list<std::string>         classNames;             //!< a List of all Names of all classes, that have registered so far.
 };
 
Index: branches/std/src/lib/particles/dot_particles.h
===================================================================
--- branches/std/src/lib/particles/dot_particles.h	(revision 7215)
+++ branches/std/src/lib/particles/dot_particles.h	(revision 7216)
@@ -21,5 +21,5 @@
   virtual void loadParams(const TiXmlElement* root);
 
-  void setMaterialTexture(const char* textureFile);
+  void setMaterialTexture(const std::string& textureFile);
 
   /** @returns the Material that lies on this particles */
Index: branches/std/src/lib/particles/model_particles.cc
===================================================================
--- branches/std/src/lib/particles/model_particles.cc	(revision 7215)
+++ branches/std/src/lib/particles/model_particles.cc	(revision 7216)
@@ -89,5 +89,5 @@
  * @param textureFile the Texture to load onto these ModelParticles
  */
-void ModelParticles::setMaterialTexture(const char* textureFile)
+void ModelParticles::setMaterialTexture(const std::string& textureFile)
 {
   this->material.setDiffuseMap(textureFile);
Index: branches/std/src/lib/particles/model_particles.h
===================================================================
--- branches/std/src/lib/particles/model_particles.h	(revision 7215)
+++ branches/std/src/lib/particles/model_particles.h	(revision 7216)
@@ -20,5 +20,5 @@
   virtual void loadParams(const TiXmlElement* root);
 
-  void setMaterialTexture(const char* textureFile);
+  void setMaterialTexture(const std::string& textureFile);
 
   /** @returns the Material that lies on this particles */
Index: branches/std/src/lib/particles/sprite_particles.cc
===================================================================
--- branches/std/src/lib/particles/sprite_particles.cc	(revision 7215)
+++ branches/std/src/lib/particles/sprite_particles.cc	(revision 7216)
@@ -89,5 +89,5 @@
  * @param textureFile the Texture to load onto these SpriteParticles
  */
-void SpriteParticles::setMaterialTexture(const char* textureFile)
+void SpriteParticles::setMaterialTexture(const std::string& textureFile)
 {
   this->material.setDiffuseMap(textureFile);
Index: branches/std/src/lib/particles/sprite_particles.h
===================================================================
--- branches/std/src/lib/particles/sprite_particles.h	(revision 7215)
+++ branches/std/src/lib/particles/sprite_particles.h	(revision 7216)
@@ -21,5 +21,5 @@
   virtual void loadParams(const TiXmlElement* root);
 
-  void setMaterialTexture(const char* textureFile);
+  void setMaterialTexture(const std::string& textureFile);
 
   /** @returns the Material that lies on this particles */
Index: branches/std/src/lib/physics/physics_connection.cc
===================================================================
--- branches/std/src/lib/physics/physics_connection.cc	(revision 7215)
+++ branches/std/src/lib/physics/physics_connection.cc	(revision 7216)
@@ -73,10 +73,10 @@
  * @param subjectName the name of the Subject for this PhysicsConnection
 */
-void PhysicsConnection::setSubject(const char* subjectName)
+void PhysicsConnection::setSubject(const std::string& subjectName)
 {
   this->subject = PhysicsEngine::getInstance()->getPhysicsInterfaceByName(subjectName);
   if (this->subject == NULL)
   {
-    PRINTF(2)("subject: (%s) not found for PhysicsConnection\n", subjectName);
+    PRINTF(2)("subject: (%s) not found for PhysicsConnection\n", subjectName.c_str());
   }
   else
@@ -87,10 +87,10 @@
 * @param fieldName the Name of the Field for this connection
 */
-void PhysicsConnection::setField(const char* fieldName)
+void PhysicsConnection::setField(const std::string& fieldName)
 {
   this->field = PhysicsEngine::getInstance()->getFieldByName(fieldName);
   if (this->field == NULL)
   {
-        PRINTF(2)("field: (%s) not found for PhysicsConnection\n", fieldName);
+    PRINTF(2)("field: (%s) not found for PhysicsConnection\n", fieldName.c_str());
   }
   else
Index: branches/std/src/lib/physics/physics_connection.h
===================================================================
--- branches/std/src/lib/physics/physics_connection.h	(revision 7215)
+++ branches/std/src/lib/physics/physics_connection.h	(revision 7216)
@@ -35,6 +35,6 @@
   virtual ~PhysicsConnection();
 
-  void setSubject(const char* subjectName);
-  void setField(const char* fieldName);
+  void setSubject(const std::string& subjectName);
+  void setField(const std::string& fieldName);
 
   void apply() const;
Index: branches/std/src/lib/physics/physics_engine.cc
===================================================================
--- branches/std/src/lib/physics/physics_engine.cc	(revision 7215)
+++ branches/std/src/lib/physics/physics_engine.cc	(revision 7216)
@@ -128,5 +128,5 @@
   @returns the PhysicsInterface if found, or NULL if not
  */
-PhysicsInterface* PhysicsEngine::getPhysicsInterfaceByName(const char* physicsInterfaceName) const
+PhysicsInterface* PhysicsEngine::getPhysicsInterfaceByName(const std::string& physicsInterfaceName) const
 {
   BaseObject* interface = ClassList::getObject(physicsInterfaceName, CL_PHYSICS_INTERFACE);
@@ -157,12 +157,12 @@
 
 /**
-* @param FieldName the Name of the PhysicsInterface to search for
+* @param fieldName the Name of the PhysicsInterface to search for
   @returns the Field if found, or NULL if not
  */
-Field* PhysicsEngine::getFieldByName(const char* FieldName) const
+Field* PhysicsEngine::getFieldByName(const std::string& fieldName) const
 {
   list<Field*>::const_iterator field;
   for (field = this->fields.begin(); field != this->fields.end(); field++)
-    if (!strcmp(FieldName, (*field)->getName()))
+    if (fieldName == (*field)->getName())
       return (*field);
   return NULL;
@@ -197,9 +197,9 @@
   @returns the PhysicsConnection if found, or NULL if not
  */
-PhysicsConnection* PhysicsEngine::getPhysicsConnectionByName(const char* physicsConnectionName) const
+PhysicsConnection* PhysicsEngine::getPhysicsConnectionByName(const std::string& physicsConnectionName) const
 {
   list<PhysicsConnection*>::const_iterator pc;
   for (pc = this->connections.begin(); pc != this->connections.end(); pc++)
-    if (!strcmp(physicsConnectionName, (*pc)->getName()))
+    if (physicsConnectionName == (*pc)->getName())
       delete (*pc);
   return NULL;
Index: branches/std/src/lib/physics/physics_engine.h
===================================================================
--- branches/std/src/lib/physics/physics_engine.h	(revision 7215)
+++ branches/std/src/lib/physics/physics_engine.h	(revision 7216)
@@ -31,13 +31,13 @@
   void loadConnections(const TiXmlElement* root);
 
-  PhysicsInterface*      getPhysicsInterfaceByName(const char* physicsInterfaceName) const;
+  PhysicsInterface*      getPhysicsInterfaceByName(const std::string& physicsInterfaceName) const;
 
   void                   addField(Field* field);
   void                   removeField(Field* field);
-  Field*                 getFieldByName(const char* FieldName) const;
+  Field*                 getFieldByName(const std::string& fieldName) const;
 
   void                   addConnection(PhysicsConnection* connection);
   void                   removeConnection(PhysicsConnection* connection);
-  PhysicsConnection*     getPhysicsConnectionByName(const char* physicsConnectionName) const;
+  PhysicsConnection*     getPhysicsConnectionByName(const std::string& physicsConnectionName) const;
 
 
Index: branches/std/src/lib/shell/shell.cc
===================================================================
--- branches/std/src/lib/shell/shell.cc	(revision 7215)
+++ branches/std/src/lib/shell/shell.cc	(revision 7216)
@@ -85,6 +85,5 @@
   this->lineSpacing = 0;
   this->bActive = true;
-  this->fontFile = new char[strlen(SHELL_DEFAULT_FONT)+1];
-  strcpy(this->fontFile, SHELL_DEFAULT_FONT);
+  this->fontFile = SHELL_DEFAULT_FONT;
 
 
@@ -110,5 +109,4 @@
     delete this->bufferText[i];
   delete[] this->bufferText;
-  delete[] this->fontFile;
   // delete the inputLine
   delete this->shellInput;
@@ -139,5 +137,5 @@
     if (!top)
     {
-      this->bufferText[i]->setText((*textLine), true);
+      this->bufferText[i]->setText((*textLine));
     if (textLine != ShellBuffer::getInstance()->getBuffer()->begin())
       top = true;
@@ -167,5 +165,5 @@
     if (textLine != ShellBuffer::getInstance()->getBuffer()->begin())
     {
-      this->bufferText[i]->setText((*textLine), false);
+      this->bufferText[i]->setText((*textLine));
       textLine--;
     }
@@ -181,14 +179,10 @@
  * (be aware that within orxonox fontFile is relative to the Data-Dir)
  */
-void Shell::setFont(const char* fontFile)
+void Shell::setFont(const std::string& fontFile)
 {
 //   if (!ResourceManager::isInDataDir(fontFile))
 //     return false;
 
-  if (this->fontFile != NULL)
-    delete[] this->fontFile;
-
-  this->fontFile = new char[strlen(fontFile)+1];
-  strcpy(this->fontFile, fontFile);
+  this->fontFile = fontFile;
 
   this->rebuildText();
@@ -245,5 +239,5 @@
  * @param fileName the filename of the Image to load
  */
-void Shell::setBackgroundImage(const char* fileName)
+void Shell::setBackgroundImage(const std::string& fileName)
 {
   this->backgroundMaterial->setDiffuseMap(fileName);
@@ -340,5 +334,5 @@
     for (int i = 0; i < this->bufferDisplaySize; i++)
     {
-      this->bufferText[i]->setText(NULL, true);
+      this->bufferText[i]->setText("");
     }
 
@@ -351,5 +345,5 @@
  * @param text the text to output.
  */
-void Shell::printToDisplayBuffer(const char* text)
+void Shell::printToDisplayBuffer(const std::string& text)
 {
   if(likely(bufferText != NULL))
@@ -382,5 +376,5 @@
     this->bufferText[0] = lastText;
 
-    this->bufferText[0]->setText(text, true);
+    this->bufferText[0]->setText(text);
   }
 }
@@ -427,5 +421,5 @@
   for (unsigned int i = 0; i < this->bufferDisplaySize; i++)
   {
-    this->bufferText[i]->setText((*it), false);
+    this->bufferText[i]->setText((*it));
     it--;
   }
Index: branches/std/src/lib/shell/shell.h
===================================================================
--- branches/std/src/lib/shell/shell.h	(revision 7215)
+++ branches/std/src/lib/shell/shell.h	(revision 7216)
@@ -53,9 +53,9 @@
     inline bool isActive() const { return this->bActive; };
 
-    void setFont(const char* fontFile);
+    void setFont(const std::string& fontFile);
     void setTextSize(unsigned int textSize, unsigned int lineSpacing = 1);
     void setTextColor(float r, float g, float b, float a);
     void setBackgroundColor(float r, float g, float b, float a);
-    void setBackgroundImage(const char* fileName);
+    void setBackgroundImage(const std::string& fileName);
 
     void resetValues();
@@ -64,5 +64,5 @@
     // BUFFERS
     void setBufferDisplaySize(unsigned int bufferDisplaySize);
-    void printToDisplayBuffer(const char* text);
+    void printToDisplayBuffer(const std::string& text);
     void moveDisplayBuffer(int lineCount);
 
@@ -83,8 +83,8 @@
 
     //     void testI (int i);
-    //     void testS (const char* s);
+    //     void testS (const std::string& s);
     //     void testB (bool b);
     //     void testF (float f);
-    //     void testSF (const char* s, float f);
+    //     void testSF (const std::string& s, float f);
 
   private:
@@ -95,5 +95,5 @@
     unsigned int                textSize;               //!< The size of the text.
     float                       textColor[4];           //!< The text's color [r,g,b,a].
-    char*                       fontFile;               //!< The file containing the font.
+    std::string                 fontFile;               //!< The file containing the font.
     Material*                   backgroundMaterial;     //!< A material for the background.
 
Index: branches/std/src/lib/shell/shell_command.cc
===================================================================
--- branches/std/src/lib/shell/shell_command.cc	(revision 7215)
+++ branches/std/src/lib/shell/shell_command.cc	(revision 7216)
@@ -153,5 +153,5 @@
  * @return true on success, false otherwise.
  */
-bool ShellCommand::execute(const char* executionString)
+bool ShellCommand::execute(const std::string& executionString)
 {
   if (ShellCommandClass::commandClassList == NULL)
@@ -184,5 +184,8 @@
           {
             if (inputSplits.getCount() > 1)
-              (*alias)->getCommand()->executor->execute(objectList->front(), executionString+inputSplits.getOffset(1));
+            {
+
+              (*alias)->getCommand()->executor->execute(objectList->front(), executionString.substr(inputSplits.getOffset(1), executionString.size())); /// TODO CHECK IF OK
+            }
             else
               (*alias)->getCommand()->executor->execute(objectList->front(), "");
@@ -240,5 +243,5 @@
               return false;
             if (inputSplits.getCount() > fktPos+1)
-              (*cmdIT)->executor->execute(objectPointer, executionString+inputSplits.getOffset(fktPos +1));
+              (*cmdIT)->executor->execute(objectPointer, executionString.substr(inputSplits.getOffset(fktPos +1), executionString.size())); /// TODO CHECK IF OK
             else
               (*cmdIT)->executor->execute(objectPointer, "");
@@ -326,5 +329,5 @@
   for (classIT = ShellCommandClass::commandClassList->begin(); classIT != ShellCommandClass::commandClassList->end(); classIT++)
   {
-    PRINT(0)("Class:'%s' registered %d commands: \n", (*classIT)->className, (*classIT)->commandList.size());
+    PRINT(0)("Class:'%s' registered %d commands: \n", (*classIT)->className.c_str(), (*classIT)->commandList.size());
 
     list<ShellCommand*>::iterator cmdIT;
Index: branches/std/src/lib/shell/shell_command.h
===================================================================
--- branches/std/src/lib/shell/shell_command.h	(revision 7215)
+++ branches/std/src/lib/shell/shell_command.h	(revision 7216)
@@ -61,5 +61,5 @@
   friend class ShellCommandClass;
   public:
-    static bool execute (const char* executionString);
+    static bool execute (const std::string& executionString);
 
     ShellCommand* describe(const char* description);
Index: branches/std/src/lib/shell/shell_command_class.cc
===================================================================
--- branches/std/src/lib/shell/shell_command_class.cc	(revision 7215)
+++ branches/std/src/lib/shell/shell_command_class.cc	(revision 7216)
@@ -36,10 +36,10 @@
  * @param className the Name of the command-class to create
  */
-ShellCommandClass::ShellCommandClass(const char* className)
+ShellCommandClass::ShellCommandClass(const std::string& className)
+  : className(className)
 {
   this->setClassID(CL_SHELL_COMMAND_CLASS, "ShellCommandClass");
   this->setName(className);
 
-  this->className = className;
   this->classID = CL_NULL;
 
@@ -65,7 +65,7 @@
  * @returns true on success, false otherwise
  */
-bool ShellCommandClass::getCommandListOfClass(const char* className, std::list<const char*>* stringList)
-{
-  if (stringList == NULL || className == NULL)
+bool ShellCommandClass::getCommandListOfClass(const std::string& className, std::list<std::string>* stringList)
+{
+  if (stringList == NULL)
     return false;
 
@@ -73,5 +73,5 @@
   for(elem = ShellCommandClass::commandClassList->begin(); elem != ShellCommandClass::commandClassList->end(); elem++)
   {
-    if (!strcmp ((*elem)->getName(), className))
+    if (className == (*elem)->getName())
     {
       list<ShellCommand*>::iterator command;
@@ -88,5 +88,5 @@
  * @returns true on success, false otherwise
  */
-bool ShellCommandClass::getCommandListOfAlias(std::list<const char*>* stringList)
+bool ShellCommandClass::getCommandListOfAlias(std::list<std::string>* stringList)
 {
   if (stringList == NULL || ShellCommandClass::aliasList == NULL)
@@ -138,5 +138,5 @@
   for (classIT = ShellCommandClass::commandClassList->begin(); classIT != ShellCommandClass::commandClassList->end(); classIT++)
   {
-    if (!strcmp(className, (*classIT)->className))
+    if (className == (*classIT)->className)
     {
       if ((*classIT)->classID == CL_NULL)
@@ -154,5 +154,5 @@
  * @returns the CommandClass if found, or a new CommandClass if not
  */
-ShellCommandClass* ShellCommandClass::getCommandClass(const char* className)
+ShellCommandClass* ShellCommandClass::getCommandClass(const std::string& className)
 {
   if (ShellCommandClass::commandClassList == NULL)
@@ -162,5 +162,5 @@
   for (classIT = ShellCommandClass::commandClassList->begin(); classIT != ShellCommandClass::commandClassList->end(); classIT++)
   {
-    if (!strcmp(className, (*classIT)->className))
+    if (className == (*classIT)->className)
     {
       return (*classIT);
@@ -186,8 +186,6 @@
  * @param className: the Class of Commands to show help about
  */
-void ShellCommandClass::help(const char* className)
-{
-  if (className == NULL)
-    return;
+void ShellCommandClass::help(const std::string& className)
+{
   if (likely(ShellCommandClass::commandClassList != NULL))
   {
@@ -195,7 +193,7 @@
     for (classIT = ShellCommandClass::commandClassList->begin(); classIT != ShellCommandClass::commandClassList->end(); classIT++)
     {
-      if ((*classIT)->className && !strcasecmp(className, (*classIT)->className))
+      if (className == (*classIT)->className)
       {
-        PRINT(0)("Class:'%s' registered %d commands: \n", (*classIT)->className, (*classIT)->commandList.size());
+        PRINT(0)("Class:'%s' registered %d commands: \n", (*classIT)->className.c_str(), (*classIT)->commandList.size());
         list<ShellCommand*>::const_iterator cmdIT;
         for (cmdIT = (*classIT)->commandList.begin(); cmdIT != (*classIT)->commandList.end(); cmdIT++)
@@ -212,5 +210,5 @@
       }
     }
-    PRINTF(3)("Class %s not found in Command's classes\n", className);
+    PRINTF(3)("Class %s not found in Command's classes\n", className.c_str());
   }
   else
Index: branches/std/src/lib/shell/shell_command_class.h
===================================================================
--- branches/std/src/lib/shell/shell_command_class.h	(revision 7215)
+++ branches/std/src/lib/shell/shell_command_class.h	(revision 7216)
@@ -27,14 +27,14 @@
     /** @returns the CommandClassList */
     static const std::list<ShellCommandClass*>* getCommandClassList() { return ShellCommandClass::commandClassList; };
-    static bool getCommandListOfClass(const char* className, std::list<const char*>* stringList);
-    static bool getCommandListOfAlias(std::list<const char*>* aliasList);
+    static bool getCommandListOfClass(const std::string& className, std::list<std::string>* stringList);
+    static bool getCommandListOfAlias(std::list<std::string>* aliasList);
 
-    static ShellCommandClass* getCommandClass(const char* className);
+    static ShellCommandClass* getCommandClass(const std::string& className);
     static void unregisterAllCommands();
 
-    static void help (const char* className);
+    static void help (const std::string& className);
 
   private:
-    ShellCommandClass(const char* className);
+    ShellCommandClass(const std::string& className);
     virtual ~ShellCommandClass();
 
@@ -43,5 +43,5 @@
 
   private:
-    const char*                            className;                 //!< The Name of the Class. This should match the ClassName of the Commands Class.
+    const std::string                      className;                 //!< The Name of the Class. This should match the ClassName of the Commands Class.
     long                                   classID;                   //!< The classID of this Class
     std::list<ShellCommand*>               commandList;               //!< A list of Commands from this Class
Index: branches/std/src/lib/shell/shell_completion.cc
===================================================================
--- branches/std/src/lib/shell/shell_completion.cc	(revision 7215)
+++ branches/std/src/lib/shell/shell_completion.cc	(revision 7216)
@@ -76,6 +76,5 @@
 
   // Check if we are in a input. eg. the supplied string "class " and now we complete either function or object
-  if (this->input->getInput() != NULL &&
-      strrchr(this->input->getInput(), ' ') >= this->input->getInput() + strlen(this->input->getInput())-1)
+  if (this->input->getInput()[this->input->getInput().size()-1] == ' ')
   {
     emptyComplete = true;
@@ -83,9 +82,5 @@
 
   // CREATE INPUTS
-  if (this->input->getInput() == NULL)
-    completionLine = "";
-  else
-    completionLine = this->input->getInput() + strspn(this->input->getInput(), " \t\n");
-  SubString inputSplits(completionLine, " \t\n,");
+  SubString inputSplits(this->input->getInput(), " \t\n,");
 
   // What String will be completed
@@ -151,5 +146,5 @@
   if (unlikely(classBegin == NULL))
     return false;
-  const std::list<const char*>* clList = ClassList::getClassNames();
+  const std::list<std::string>* clList = ClassList::getClassNames();
   if (clList != NULL)
   {
@@ -195,5 +190,5 @@
   if (unlikely(functionBegin == NULL))
     return false;
-  std::list<const char*> fktList;
+  std::list<std::string> fktList;
   ShellCommandClass::getCommandListOfClass(className, &fktList);
   //printf("%s\n", boList->firstElement()->getName());
@@ -212,5 +207,5 @@
   if (unlikely(aliasBegin == NULL))
     return false;
-  std::list<const char*> aliasList;
+  std::list<std::string> aliasList;
   ShellCommandClass::getCommandListOfAlias(&aliasList);
   //printf("%s\n", boList->firstElement()->getName());
@@ -295,5 +290,5 @@
  * !! The strings MUST NOT be deleted !!
  */
-bool ShellCompletion::addToCompleteList(const std::list<const char*>* inputList, const char* completionBegin, SHELLC_TYPE type)
+bool ShellCompletion::addToCompleteList(const std::list<std::string>* inputList, const char* completionBegin, SHELLC_TYPE type)
 {
   if (inputList == NULL || completionBegin == NULL)
@@ -301,12 +296,12 @@
   unsigned int searchLength = strlen(completionBegin);
 
-  list<const char*>::const_iterator string;
+  list<std::string>::const_iterator string;
   for (string = inputList->begin(); string != inputList->end(); string++)
   {
-    if (strlen(*string) >= searchLength &&
-        !strncasecmp(*string, completionBegin, searchLength))
+    if ((*string).size() >= searchLength &&
+          !strncasecmp((*string).c_str(), completionBegin, searchLength))
     {
       ShellC_Element newElem;
-      newElem.name = *string;
+      newElem.name = (*string).c_str();
       newElem.type = type;
       this->completionList.push_back(newElem);
Index: branches/std/src/lib/shell/shell_completion.h
===================================================================
--- branches/std/src/lib/shell/shell_completion.h	(revision 7215)
+++ branches/std/src/lib/shell/shell_completion.h	(revision 7216)
@@ -52,5 +52,5 @@
   bool generalComplete(const char* begin, const char* displayAs = "%s", const char* addBack = NULL, const char* addFront = NULL);
 
-  bool addToCompleteList(const std::list<const char*>* inputList, const char* completionBegin, SHELLC_TYPE type);
+  bool addToCompleteList(const std::list<std::string>* inputList, const char* completionBegin, SHELLC_TYPE type);
   bool addToCompleteList(const std::list<BaseObject*>* inputList, const char* completionBegin, SHELLC_TYPE type);
   void emptyCompletionList();
Index: branches/std/src/lib/shell/shell_input.cc
===================================================================
--- branches/std/src/lib/shell/shell_input.cc	(revision 7215)
+++ branches/std/src/lib/shell/shell_input.cc	(revision 7216)
@@ -46,6 +46,5 @@
   this->setClassID(CL_SHELL_INPUT, "ShellInput");
 
-  this->inputLine = new char[1];
-  this->inputLine[0] = '\0';
+  this->inputLine = "";
   this->historyIT = this->history.begin();
   this->setHistoryLength(50);
@@ -70,10 +69,8 @@
 {
   // delete what has to be deleted here
-  delete[] this->inputLine;
   delete this->completion;
 
   while (!this->history.empty())
   {
-    delete[] this->history.front();
     this->history.pop_front();
   }
@@ -96,11 +93,6 @@
 void ShellInput::flush()
 {
-  if (likely(this->inputLine != NULL))
-  {
-    delete[] this->inputLine;
-  }
-  this->inputLine = new char[1];
-  *this->inputLine = '\0';
-  this->setText(this->inputLine, true);
+  this->inputLine.clear();
+  this->setText(this->inputLine);
 }
 
@@ -109,18 +101,8 @@
  * @param text the new Text to set as InputLine
  */
-void ShellInput::setInputText(const char* text)
-{
-  delete[] this->inputLine;
-  if (text == NULL)
-  {
-    this->inputLine = new char[1];
-    this->inputLine[0] = '\0';
-  }
-  else
-  {
-    this->inputLine = new char[strlen(text)+1];
-    strcpy(this->inputLine, text);
-  }
-  this->setText(this->inputLine, true);
+void ShellInput::setInputText(const std::string& text)
+{
+  this->inputLine = text;
+  this->setText(this->inputLine);
 }
 
@@ -134,15 +116,10 @@
   if (this->historyScrolling)
   {
-    delete[] this->history.back();
     this->history.pop_back();
     this->historyScrolling = false;
   }
 
-  char* addCharLine = new char[strlen(this->inputLine)+2];
-
-  sprintf(addCharLine, "%s%c", this->inputLine, character);
-  delete[] this->inputLine;
-  this->inputLine = addCharLine;
-  this->setText(this->inputLine, true);
+  this->inputLine += character;
+  this->setText(this->inputLine);
 }
 
@@ -151,19 +128,14 @@
  * @param characters a \\0 terminated char-array to add to the InputLine
  */
-void ShellInput::addCharacters(const char* characters)
+void ShellInput::addCharacters(const std::string& characters)
 {
   if (this->historyScrolling)
   {
-    delete[] this->history.back();
     this->history.pop_back();
     this->historyScrolling = false;
   }
 
-  char* addCharLine = new char[strlen(this->inputLine)+strlen(characters)+1];
-
-  sprintf(addCharLine, "%s%s", this->inputLine, characters);
-  delete[] this->inputLine;
-  this->inputLine = addCharLine;
-  this->setText(this->inputLine, true);
+  this->inputLine += characters;
+  this->setText(this->inputLine);
 }
 
@@ -176,22 +148,12 @@
   if (this->historyScrolling)
   {
-    delete[] this->history.back();
     this->history.pop_back();
     this->historyScrolling = false;
   }
-
-  if (strlen(this->inputLine) == 0)
-    return;
-
-  if (characterCount > strlen(this->inputLine))
-    characterCount = strlen(this->inputLine);
-
-  char* removeCharLine = new char[strlen(this->inputLine)-characterCount+1];
-
-  strncpy(removeCharLine, this->inputLine, strlen(this->inputLine)-characterCount);
-  removeCharLine[strlen(this->inputLine)-characterCount] = '\0';
-  delete[] this->inputLine;
-  this->inputLine = removeCharLine;
-  this->setText(this->inputLine, true);
+  if (this->inputLine.size() < characterCount)
+    characterCount = this->inputLine.size();
+
+  this->inputLine.erase(this->inputLine.size() - characterCount, this->inputLine.size());
+  this->setText(this->inputLine);
 }
 
@@ -202,18 +164,14 @@
 bool ShellInput::executeCommand()
 {
-  ShellBuffer::addBufferLineStatic("Execute Command: %s\n", this->inputLine);
-
-  if (strlen(this->inputLine) == 0)
+  ShellBuffer::addBufferLineStatic("Execute Command: %s\n", this->inputLine.c_str());
+
+  if (this->inputLine.empty())
     return false;
 
-  char* newCommand = new char[strlen(this->inputLine)+1];
-  strcpy(newCommand, this->inputLine);
-
-  ShellCommand::execute(newCommand);
+  ShellCommand::execute(this->inputLine);
 
   // removing the eventually added Entry (from scrolling) to the List
   if (this->historyScrolling)
   {
-    delete[] this->history.back();
     this->history.pop_back();
     this->historyScrolling = false;
@@ -221,8 +179,7 @@
 
   // adding the new Command to the History
-  this->history.push_back(newCommand);
+  this->history.push_back(this->inputLine);
   if (this->history.size() > this->historyLength)
   {
-    delete[] this->history.front();
     this->history.pop_front();
   }
@@ -241,7 +198,5 @@
   if (!this->historyScrolling)
   {
-    char* currentText = new char[strlen(this->inputLine)+1];
-    strcpy(currentText, this->inputLine);
-    this->history.push_back(currentText);
+    this->history.push_back(this->inputLine);
     this->historyScrolling = true;
     this->historyIT = --this->history.end();
@@ -250,8 +205,8 @@
   if(this->historyIT != this->history.begin())
   {
-    char* prevElem = *(--this->historyIT);
-    if (prevElem == NULL)
+    std::string prevElem = *(--this->historyIT);
+    /*if (prevElem == NULL) /// TODO STD
       return;
-    else
+    else */
     {
       this->flush();
@@ -270,8 +225,8 @@
   if (this->historyIT != this->history.end())
   {
-    char* nextElem = *(++this->historyIT);
-    if (nextElem == NULL)
+    std::string nextElem = *(++this->historyIT);
+    /*    if (nextElem == NULL) /// TODO FIX STD
       return;
-    else
+    else */
     {
       this->flush();
@@ -285,9 +240,9 @@
  * prints out some nice help about the Shell
  */
-void ShellInput::help(const char* className, const char* functionName)
-{
-  printf("%s::%s\n", className, functionName);
-
-  if (strlen(className) == 0)
+void ShellInput::help(const std::string& className, const std::string& functionName)
+{
+  printf("%s::%s\n", className.c_str(), functionName.c_str());
+
+  if (className.empty())
   {
     PRINT(0)("Help for the most important Shell-commands\n");
@@ -298,5 +253,5 @@
     PRINT(0)("- Also try 'help className'");
   }
-  else if (strlen (className) > 0 && strlen (functionName) == 0)
+  else if (!className.empty() && functionName.empty())
   {
     ShellCommandClass::help(className);
Index: branches/std/src/lib/shell/shell_input.h
===================================================================
--- branches/std/src/lib/shell/shell_input.h	(revision 7215)
+++ branches/std/src/lib/shell/shell_input.h	(revision 7216)
@@ -31,11 +31,11 @@
 
   /** @returns the inputLine */
-  const char* getInput() const { return this->inputLine; };
+  const std::string& getInput() const { return this->inputLine; };
 
   // InputLine
   void flush();
-  void setInputText(const char* text);
+  void setInputText(const std::string& text);
   void addCharacter(char character);
-  void addCharacters(const char* characters);
+  void addCharacters(const std::string& characters);
   void removeCharacters(unsigned int characterCount = 1);
   void setRepeatDelay(float repeatDelay, float repeatRate);
@@ -47,5 +47,5 @@
   void historyMoveDown();
 
-  void help(const char* className = "", const char* function = "");
+  void help(const std::string& className = "", const std::string& function = "");
 
   virtual void tick(float dt);
@@ -54,16 +54,16 @@
  private:
     // HANDLING TEXT INPUT
-   ShellCompletion*            completion;             //!< The Completion Interface.
+   ShellCompletion*                  completion;       //!< The Completion Interface.
 
-   char*                       inputLine;              //!< the Char-Array of the Buffer
-   float                       repeatRate;             //!< The Repeat-Delay.
-   float                       repeatDelay;            //!< The delay of the first Character of a given Character.
-   float                       delayed;                //!< how much of the delay is remaining.
-   Uint16                      pressedKey;             //!< the pressed key that will be repeated.
+   std::string                       inputLine;        //!< the Char-Array of the Buffer
+   float                             repeatRate;       //!< The Repeat-Delay.
+   float                             repeatDelay;      //!< The delay of the first Character of a given Character.
+   float                             delayed;          //!< how much of the delay is remaining.
+   Uint16                            pressedKey;       //!< the pressed key that will be repeated.
 
-   std::list<char*>            history;                //!< The history of given commands.
-   std::list<char*>::iterator  historyIT;
-   unsigned int                historyLength;          //!< The maximum length of the InputHistory.
-   bool                        historyScrolling;       //!< true if we are scrolling through the history.
+   std::list<std::string>            history;          //!< The history of given commands.
+   std::list<std::string>::iterator  historyIT;        //!< The locator that tells us, where we are in the history.
+   unsigned int                      historyLength;    //!< The maximum length of the InputHistory.
+   bool                              historyScrolling; //!< true if we are scrolling through the history.
 };
 
Index: branches/std/src/lib/util/executor/executor.h
===================================================================
--- branches/std/src/lib/util/executor/executor.h	(revision 7215)
+++ branches/std/src/lib/util/executor/executor.h	(revision 7216)
@@ -271,7 +271,5 @@
     {
       SubString sub;
-      printf("===%s\n", parameters.c_str());
       sub.split(parameters, " \n\t,", '\\');
-      sub.debug();
 //! FUNCTOR_LIST is the List of Executive Functions
 #define FUNCTOR_LIST(x) ExecutorExecute ## x
Index: branches/std/src/lib/util/executor/functor_list.h
===================================================================
--- branches/std/src/lib/util/executor/functor_list.h	(revision 7215)
+++ branches/std/src/lib/util/executor/functor_list.h	(revision 7216)
@@ -98,13 +98,4 @@
 
   FUNCTOR_LIST(0)();
-  //! makes functions with one cstring
-  FUNCTOR_LIST(1)(l_CSTRING);
-  //! makes functions with two cstrings
-  FUNCTOR_LIST(2)(l_CSTRING, l_CSTRING);
-  //! makes functions with three cstrings
-  FUNCTOR_LIST(3)(l_CSTRING, l_CSTRING, l_CSTRING);
-  //! makes functions with four cstrings
-  FUNCTOR_LIST(4)(l_CSTRING, l_CSTRING, l_CSTRING, l_CSTRING);
-
   //! makes functions with one string
   FUNCTOR_LIST(1)(l_STRING);
@@ -151,9 +142,9 @@
 
   //! mixed values:
-  FUNCTOR_LIST(2)(l_CSTRING, l_FLOAT);
+  FUNCTOR_LIST(2)(l_STRING, l_FLOAT);
   FUNCTOR_LIST(2)(l_UINT, l_LONG);
-  FUNCTOR_LIST(2)(l_CSTRING, l_UINT);
+  FUNCTOR_LIST(2)(l_STRING, l_UINT);
 
-  FUNCTOR_LIST(3)(l_CSTRING, l_FLOAT, l_UINT);
+  FUNCTOR_LIST(3)(l_STRING, l_FLOAT, l_UINT);
 
 
Index: branches/std/src/lib/util/helper_functions.cc
===================================================================
--- branches/std/src/lib/util/helper_functions.cc	(revision 7215)
+++ branches/std/src/lib/util/helper_functions.cc	(revision 7216)
@@ -104,13 +104,7 @@
 {
   if (STRING.size() > 0)
-  {
-    printf("DECISION1: %s\n", STRING.c_str());
     return STRING;
-  }
   else
-  {
-    printf("DECISION2: %s\n", defaultValue.c_str());
     return defaultValue;
-  }
 }
 
Index: branches/std/src/lib/util/loading/load_param.cc
===================================================================
--- branches/std/src/lib/util/loading/load_param.cc	(revision 7215)
+++ branches/std/src/lib/util/loading/load_param.cc	(revision 7216)
@@ -66,5 +66,5 @@
           ((this->executor->getType() & Executor_NoLoadString) == Executor_NoLoadString)))
     {
-      PRINTF(0)("Loading value '%s' with Parameters '%s' onto: %s::%s\n", this->paramName.c_str(), loadString.c_str(), this->object->getClassName(), this->object->getName());
+      PRINTF(4)("Loading value '%s' with Parameters '%s' onto: %s::%s\n", this->paramName.c_str(), loadString.c_str(), this->object->getClassName(), this->object->getName());
       this->executor->execute(this->object, loadString);
     }
Index: branches/std/src/story_entities/game_world_data.cc
===================================================================
--- branches/std/src/story_entities/game_world_data.cc	(revision 7215)
+++ branches/std/src/story_entities/game_world_data.cc	(revision 7216)
@@ -343,5 +343,5 @@
 
   if (this->music != NULL)
-    this->setSoundTrack(NULL);
+    this->setSoundTrack("");
   this->music = NULL;
   /* stop the sound eninge */
@@ -354,5 +354,5 @@
 
 
-void GameWorldData::setSoundTrack(const char* name)
+void GameWorldData::setSoundTrack(const std::string& name)
 {
   if (this->music != NULL)
@@ -360,7 +360,7 @@
   this->music = NULL;
 
-  if (name != NULL)
-  {
-    PRINTF(3)("Setting Sound Track to %s\n", name);
+  if (!name.empty())
+  {
+    PRINTF(3)("Setting Sound Track to %s\n", name.c_str());
     std::string oggFile = ResourceManager::getFullName(name);
     this->music = new OggPlayer(oggFile);
Index: branches/std/src/story_entities/game_world_data.h
===================================================================
--- branches/std/src/story_entities/game_world_data.h	(revision 7215)
+++ branches/std/src/story_entities/game_world_data.h	(revision 7216)
@@ -42,5 +42,5 @@
 
     /* interface functions */
-    void setSoundTrack(const char* name);
+    void setSoundTrack(const std::string& name);
     void loadGameRule(const TiXmlElement* root);
 
Index: branches/std/src/util/Makefile.am
===================================================================
--- branches/std/src/util/Makefile.am	(revision 7215)
+++ branches/std/src/util/Makefile.am	(revision 7216)
@@ -15,6 +15,7 @@
 			animation/animation_player.cc \
 			\
-			track/pilot_node.cc \
-			track/track_manager.cc \
+			track/pilot_node.cc
+
+#			track/track_manager.cc \
 			track/track_node.cc
 
@@ -31,5 +32,6 @@
 			animation/t_animation.h \
 			\
-			track/pilot_node.h \
-			track/track_manager.h \
+			track/pilot_node.h
+
+#			track/track_manager.h \
 			track/track_node.h
Index: branches/std/src/util/fast_factory.cc
===================================================================
--- branches/std/src/util/fast_factory.cc	(revision 7215)
+++ branches/std/src/util/fast_factory.cc	(revision 7216)
@@ -29,5 +29,5 @@
  * @return a new FastFactory
  */
-FastFactory::FastFactory (ClassID classID, const char* fastFactoryName)
+FastFactory::FastFactory (ClassID classID, const std::string& fastFactoryName)
 {
   this->setClassID(CL_FAST_FACTORY, "FastFactory");
@@ -119,5 +119,5 @@
  * @returns true if found, false otherwise.
  */
-FastFactory* FastFactory::searchFastFactory(const char* fastFactoryName)
+FastFactory* FastFactory::searchFastFactory(const std::string& fastFactoryName)
 {
   if (FastFactory::first == NULL)
@@ -128,5 +128,5 @@
     while (tmpFac != NULL)
     {
-      if (strcmp(tmpFac->getName(), fastFactoryName))
+      if (fastFactoryName == tmpFac->getName())
         return tmpFac;
       tmpFac = tmpFac->next;
Index: branches/std/src/util/fast_factory.h
===================================================================
--- branches/std/src/util/fast_factory.h	(revision 7215)
+++ branches/std/src/util/fast_factory.h	(revision 7216)
@@ -80,10 +80,10 @@
 
     static FastFactory* searchFastFactory(ClassID classID);
-    static FastFactory* searchFastFactory(const char* fastFactoryName);
+    static FastFactory* searchFastFactory(const std::string& fastFactoryName);
 
     ClassID getStoredID() const { return this->storedClassID; };
 
   protected:
-    FastFactory (ClassID classID, const char* fastFactoryName = NULL);
+    FastFactory (ClassID classID, const std::string& fastFactoryName = "");
 
     /** sets the Next factory in the list @param nextFactory the next factory */
Index: branches/std/src/util/multiplayer_team_deathmatch.cc
===================================================================
--- branches/std/src/util/multiplayer_team_deathmatch.cc	(revision 7215)
+++ branches/std/src/util/multiplayer_team_deathmatch.cc	(revision 7216)
@@ -92,5 +92,5 @@
 
 
-void MultiplayerTeamDeathmatch::setDeathScreen(const char* imageName)
+void MultiplayerTeamDeathmatch::setDeathScreen(const std::string& imageName)
 {
   if( this->deathScreen)
Index: branches/std/src/util/multiplayer_team_deathmatch.h
===================================================================
--- branches/std/src/util/multiplayer_team_deathmatch.h	(revision 7215)
+++ branches/std/src/util/multiplayer_team_deathmatch.h	(revision 7216)
@@ -38,5 +38,5 @@
     inline void setDeathPenaltyTimeout(float time) { this->deathTimeout = time; }
     inline void setMaxKills(int kills) { this->maxKills = kills; }
-    void setDeathScreen(const char* imageName);
+    void setDeathScreen(const std::string& imageName);
 
   protected:
Index: branches/std/src/util/object_manager.cc
===================================================================
--- branches/std/src/util/object_manager.cc	(revision 7215)
+++ branches/std/src/util/object_manager.cc	(revision 7216)
@@ -97,5 +97,5 @@
  * this function also does a transformation from omList as char* to OM_LIST.
  */
-void ObjectManager::toList (WorldEntity* entity, const char* omList)
+void ObjectManager::toList (WorldEntity* entity, const std::string& omList)
 {
   this->toList(entity, ObjectManager::StringToOMList(omList));
@@ -153,10 +153,10 @@
  * @param level: level 0: only show list info; level 1: also show entities and their names.
  */
-void ObjectManager::debug(const char* listName, unsigned int level)
+void ObjectManager::debug(const std::string& listName, unsigned int level)
 {
   PRINT(0)("=================================\n");
   PRINT(0)("=ObjectManager-DEBUG=============\n");
   PRINT(0)("=================================\n");
-  if (listName == NULL || listName[0] == '\0')
+  if (listName.empty())
     for (unsigned int i = 0; i < OM_SIZE; ++i)
       debug((OM_LIST) i, level);
@@ -189,10 +189,10 @@
  * @returns the OM_LIST transformed from listName. or the default, if not found or NULL.
  */
-OM_LIST ObjectManager::StringToOMList(const char* listName)
-{
-  if (unlikely(listName == NULL)) return OM_DEFAULT_LIST;
+OM_LIST ObjectManager::StringToOMList(const std::string& listName)
+{
+  if (unlikely(listName.empty())) return OM_DEFAULT_LIST;
 
   for(unsigned int i = 0; i < OM_SIZE; ++i) {
-    if(!strcmp(listName, ObjectManager::objectManagerListNames[i])) {
+    if(listName == ObjectManager::objectManagerListNames[i]) {
       return (OM_LIST)i;
     }
Index: branches/std/src/util/object_manager.h
===================================================================
--- branches/std/src/util/object_manager.h	(revision 7215)
+++ branches/std/src/util/object_manager.h	(revision 7216)
@@ -76,5 +76,5 @@
 
   void toList (WorldEntity* entity, OM_LIST omList = OM_DEFAULT_LIST);
-  void toList (WorldEntity* entity, const char* omList);
+  void toList (WorldEntity* entity, const std::string& omList);
 
 
@@ -85,7 +85,7 @@
 
   void debug(OM_LIST omList, unsigned int level = 0) const;
-  void debug(const char* listName = NULL, unsigned int level = 0);
+  void debug(const std::string& listName = "", unsigned int level = 0);
 
-  static OM_LIST StringToOMList(const char* listName);
+  static OM_LIST StringToOMList(const std::string& listName);
   static const char* OMListToString(OM_LIST omList);
 
Index: branches/std/src/util/track/track_manager.h
===================================================================
--- branches/std/src/util/track/track_manager.h	(revision 7215)
+++ branches/std/src/util/track/track_manager.h	(revision 7216)
@@ -142,5 +142,5 @@
   // Methods to change the Path (initialisation)
   void workOn(unsigned int trackID);
-  void workOnS(const char* trackName);
+  void workOnS(const std::string& trackName);
 
   /** \see setCurveType(CurveType curveType, TrackElement* trackElem); @param curveType the type of the Curve */
@@ -157,5 +157,5 @@
   void fork(unsigned int count, ...);
   void forkS(unsigned int count, ...);
-  void forkS(const char* forkString);
+  void forkS(const std::string& forkString);
   void forkV(unsigned int count, int* trackIDs, char** trackNames, TrackElement* trackElem = NULL);
   void condition(unsigned int trackID, CONDITION cond, void* subject);
Index: branches/std/src/world_entities/elements/text_element.cc
===================================================================
--- branches/std/src/world_entities/elements/text_element.cc	(revision 7215)
+++ branches/std/src/world_entities/elements/text_element.cc	(revision 7216)
@@ -70,10 +70,10 @@
 }
 
-void TextElement::setText(const char* text)
+void TextElement::setText(const std::string& text)
 {
   Text::setText(text);
 }
 
-void TextElement::setFont(const char* font)
+void TextElement::setFont(const std::string& font)
 {
   Text::setFont(font, (unsigned int)this->getSizeY2D());
Index: branches/std/src/world_entities/elements/text_element.h
===================================================================
--- branches/std/src/world_entities/elements/text_element.h	(revision 7215)
+++ branches/std/src/world_entities/elements/text_element.h	(revision 7216)
@@ -29,6 +29,6 @@
   virtual void loadParams(const TiXmlElement* root);
 
-  void setText(const char* text);
-  void setFont(const char* font);
+  void setText(const std::string& text);
+  void setFont(const std::string& font);
 
  private:
Index: branches/std/src/world_entities/planet.cc
===================================================================
--- branches/std/src/world_entities/planet.cc	(revision 7215)
+++ branches/std/src/world_entities/planet.cc	(revision 7216)
@@ -45,5 +45,4 @@
   this->toList(OM_GROUP_01);
 
-  this->material = new Material();
   //this->material->setIllum(20);
   //this->material->setAmbient(0.1, 0.1, 0.1);
@@ -71,6 +70,4 @@
 {
   PRINTF(5)("Deleting Planet\n");
-  if( this->material)
-    delete this->material;
 }
 
@@ -92,7 +89,7 @@
  * @param textureName the top texture.
 */
-void Planet::setTexture(const char* textureName)
+void Planet::setTexture(const std::string& textureName)
 {
-  this->material->setDiffuseMap(textureName);
+  this->material.setDiffuseMap(textureName);
 }
 
@@ -124,5 +121,5 @@
   glRotatef (this->getAbsDir().getSpacialAxisAngle(), tmpRot.x, tmpRot.y, tmpRot.z );
 
-  this->material->select();
+  this->material.select();
 
 //   /WorldEntity::draw();
Index: branches/std/src/world_entities/planet.h
===================================================================
--- branches/std/src/world_entities/planet.h	(revision 7215)
+++ branches/std/src/world_entities/planet.h	(revision 7216)
@@ -9,7 +9,6 @@
 /* INCLUDES */
 #include "world_entity.h"
-
+#include "material.h"
 /* FORWARD DECLARATION */
-class Material;
 class Texture;
 
@@ -26,5 +25,5 @@
   void setSize(float size);
   /** assumes jpg as input-format */
-  void setTexture(const char* textureName);
+  void setTexture(const std::string& textureName);
 
 
@@ -34,5 +33,5 @@
 
  private:
-  Material*       material;        //!< Materials for the Planet. sorted by number (0-5) top, bottom, left, right, front, back
+  Material        material;        //!< Materials for the Planet. sorted by number (0-5) top, bottom, left, right, front, back
   Texture*        texture;         //!< Textures for the CubeMap.
 
Index: branches/std/src/world_entities/power_ups/param_power_up.cc
===================================================================
--- branches/std/src/world_entities/power_ups/param_power_up.cc	(revision 7215)
+++ branches/std/src/world_entities/power_ups/param_power_up.cc	(revision 7216)
@@ -81,8 +81,8 @@
 }
 
-void ParamPowerUp::setType(const char* type)
+void ParamPowerUp::setType(const std::string& type)
 {
   for(int i = 0; i < POWERUP_PARAM_size; ++i) {
-    if(strcmp(type, paramTypes[i]) == 0) {
+    if(type == paramTypes[i]) {
       this->type = (EnumParamPowerUpType)i;
       break;
Index: branches/std/src/world_entities/power_ups/param_power_up.h
===================================================================
--- branches/std/src/world_entities/power_ups/param_power_up.h	(revision 7215)
+++ branches/std/src/world_entities/power_ups/param_power_up.h	(revision 7216)
@@ -28,5 +28,5 @@
   void setMaxValue(float value);
   void setMinValue(float value);
-  void setType(const char* type);
+  void setType(const std::string& type);
   EnumParamPowerUpType getType();
   float getValue();
@@ -43,9 +43,11 @@
 
 private:
-  static const char* paramTypes[];
-  EnumParamPowerUpType type;
-  float value;
-  float max_value;
-  float min_value;
+  EnumParamPowerUpType    type;
+  float                   value;
+  float                   max_value;
+  float                   min_value;
+
+  static const char*      paramTypes[];
+
 };
 
Index: branches/std/src/world_entities/power_ups/power_up.cc
===================================================================
--- branches/std/src/world_entities/power_ups/power_up.cc	(revision 7215)
+++ branches/std/src/world_entities/power_ups/power_up.cc	(revision 7216)
@@ -182,9 +182,10 @@
   };
 
-void PowerUp::setRespawnType(const char* type)
+
+void PowerUp::setRespawnType(const std::string& type)
 {
   for(int i = 0; i < RESPAWN_size; ++i)
   {
-    if(!strcmp(type, respawnTypes[i]))
+    if(type == respawnTypes[i])
     {
       this->respawnType = (PowerUpRespawn)i;
Index: branches/std/src/world_entities/power_ups/power_up.h
===================================================================
--- branches/std/src/world_entities/power_ups/power_up.h	(revision 7215)
+++ branches/std/src/world_entities/power_ups/power_up.h	(revision 7216)
@@ -31,5 +31,5 @@
   virtual void draw () const;
   virtual void tick(float dt);
-  void setRespawnType(const char* type);
+  void setRespawnType(const std::string& type);
   void setRespawnTime(const float respawn);
 
@@ -45,14 +45,14 @@
 
 private:
-  SoundSource    soundSource;
-  SoundBuffer*   pickupBuffer;
-  SoundBuffer*   respawnBuffer;
-  Material* sphereMaterial;
-  PowerUpRespawn respawnType;
-  float respawnTime;
-  float respawnStart;
-  static const char* respawnTypes[];
+  SoundSource         soundSource;
+  SoundBuffer*        pickupBuffer;
+  SoundBuffer*        respawnBuffer;
+  Material*           sphereMaterial;
+  PowerUpRespawn      respawnType;
+  float               respawnTime;
+  float               respawnStart;
+  static const char*  respawnTypes[];
 
-  WorldEntity* collider;
+  WorldEntity*        collider;
 };
 
Index: branches/std/src/world_entities/recorder.cc
===================================================================
--- branches/std/src/world_entities/recorder.cc	(revision 7215)
+++ branches/std/src/world_entities/recorder.cc	(revision 7216)
@@ -54,5 +54,7 @@
 
   LoadParam(root, "duration", this, Recorder, setStreamDuration);
+
   LoadParam(root, "fps", this, Recorder, setFPS);
+
   LoadParam(root, "name", this, Recorder, initVideo);
 }
@@ -71,5 +73,5 @@
 
 
-void Recorder::initVideo(const char* filename)
+void Recorder::initVideo(const std::string& filename)
 {
   frame_count = 0;
@@ -78,5 +80,5 @@
 
   // auto detect the output format from the name, default is mpeg
-  output_format = guess_format(NULL, filename, NULL);
+  output_format = guess_format(NULL, filename.c_str(), NULL);
   if (!output_format)
   {
@@ -93,5 +95,5 @@
 
   format_context->oformat = output_format;
-  snprintf(format_context->filename, sizeof(format_context->filename), "%s", filename);
+  snprintf(format_context->filename, sizeof(format_context->filename), "%s", filename.c_str());
 
   // add video stream using the default format codec and initialize the codec
@@ -104,5 +106,5 @@
 
   // print some information
-  dump_format(format_context, 0, filename, 1);
+  dump_format(format_context, 0, filename.c_str(), 1);
 
   // now that all the parameters are set, we can open the
@@ -110,14 +112,14 @@
   if(video_stream)
     this->openVideo();
-  
+
   // open the output file, if needed
   if(!(output_format->flags & AVFMT_NOFILE))
   {
-    if(url_fopen(&format_context->pb, filename, URL_WRONLY) < 0)
-      PRINTF(1)("Could not open %s\n", filename);
+    if(url_fopen(&format_context->pb, filename.c_str(), URL_WRONLY) < 0)
+      PRINTF(1)("Could not open %s\n", filename.c_str());
   }
 
   // write the stream header, if any
-  av_write_header(format_context); 
+  av_write_header(format_context);
 }
 
@@ -129,7 +131,7 @@
   av_free(buffer);
 
-  // write the trailer, if any 
+  // write the trailer, if any
   av_write_trailer(format_context);
-  
+
   // free the streams
   for(int i = 0; i < format_context->nb_streams; i++)
@@ -175,5 +177,5 @@
 
 void Recorder::allocPicture()
-{ 
+{
   picture = avcodec_alloc_frame();
   if(!picture)
@@ -189,5 +191,5 @@
       return;
   }
-  avpicture_fill((AVPicture *)picture, picture_buf, 
+  avpicture_fill((AVPicture *)picture, picture_buf,
                   codec_context->pix_fmt, width, height);
 
@@ -211,5 +213,5 @@
   if (!video_stream)
     PRINTF(1)("Could not alloc stream\n");
-  
+
   codec_context = video_stream->codec;
   codec_context->codec_id = output_format->video_codec;
@@ -219,5 +221,5 @@
   codec_context->bit_rate = 400000;
   // resolution must be a multiple of two
-  codec_context->width = State::getResX();  
+  codec_context->width = State::getResX();
   codec_context->height = State::getResY();
 
@@ -229,5 +231,5 @@
   // timebase should be 1/framerate and timestamp increments should be
   // identically 1
-  codec_context->time_base.den = (int)stream_frame_rate;  
+  codec_context->time_base.den = (int)stream_frame_rate;
   codec_context->time_base.num = 1;
   codec_context->gop_size = 12;  // emit one intra frame every twelve frames at most
@@ -235,6 +237,6 @@
 
   if (codec_context->codec_id == CODEC_ID_MPEG1VIDEO)
-      // needed to avoid using macroblocks in which some coeffs overflow 
-      // this doesnt happen with normal video, it just happens here as the 
+      // needed to avoid using macroblocks in which some coeffs overflow
+      // this doesnt happen with normal video, it just happens here as the
       // motion of the chroma plane doesnt match the luma plane
       codec_context->mb_decision=2;
@@ -275,7 +277,7 @@
 {
   int out_size, err;
-  
+
   codec_context = video_stream->codec;
-  
+
   if(frame_count >= stream_nb_frames)
   {
@@ -287,5 +289,5 @@
     this->fillYuvImage();
 
-  
+
   if(format_context->oformat->flags & AVFMT_RAWPICTURE)
   {
@@ -293,10 +295,10 @@
     // futur for that
     av_init_packet(&packet);
-    
+
     packet.flags |= PKT_FLAG_KEY;
     packet.stream_index= video_stream->index;
     packet.data= (uint8_t *)picture;
     packet.size= sizeof(AVPicture);
-    
+
     err = av_write_frame(format_context, &packet);
   }
@@ -309,5 +311,5 @@
     {
       av_init_packet(&packet);
-      
+
       packet.pts= av_rescale_q(codec_context->coded_frame->pts, codec_context->time_base, video_stream->time_base);
       if(codec_context->coded_frame->key_frame)
@@ -316,5 +318,5 @@
       packet.data= buffer;
       packet.size= out_size;
-      
+
       // write the compressed frame in the media file
       err = av_write_frame(format_context, &packet);
Index: branches/std/src/world_entities/recorder.h
===================================================================
--- branches/std/src/world_entities/recorder.h	(revision 7215)
+++ branches/std/src/world_entities/recorder.h	(revision 7216)
@@ -20,30 +20,4 @@
 class Recorder : public WorldEntity
 {
-  private:
-    AVFrame* picture;
-    uint8_t* buffer;
-    int frame_count;
-    int buffer_size;
-
-    AVOutputFormat* output_format;
-    AVFormatContext* format_context;
-    AVCodecContext* codec_context;
-    AVCodec *codec;
-    AVStream* video_stream;
-    AVPacket packet;
-    double video_pts;
-
-    uint8_t *picture_buf;
-    int size;
-
-    int height;
-    int width;
-    float time;
-
-    float stream_duration;
-    float stream_frame_rate;
-    int stream_nb_frames;
-
-AVFrame* RGB_frame;
   public:
     Recorder (const TiXmlElement* root = NULL);
@@ -56,5 +30,5 @@
 
   private:
-    void initVideo(const char* filename);
+    void initVideo(const std::string& filename);
     void addVideoStream();
     void openVideo();
@@ -66,4 +40,32 @@
     void setStreamDuration(float duration);
     void setFPS(float fps);
+
+
+  private:
+    AVFrame*            picture;
+    uint8_t*            buffer;
+    int                 frame_count;
+    int                 buffer_size;
+
+    AVOutputFormat*     output_format;
+    AVFormatContext*    format_context;
+    AVCodecContext*     codec_context;
+    AVCodec*            codec;
+    AVStream*           video_stream;
+    AVPacket            packet;
+    double              video_pts;
+
+    uint8_t*            picture_buf;
+    int                 size;
+
+    int                 height;
+    int                 width;
+    float               time;
+
+    float               stream_duration;
+    float               stream_frame_rate;
+    int                 stream_nb_frames;
+
+    AVFrame*            RGB_frame;
 };
 
Index: branches/std/src/world_entities/terrain.cc
===================================================================
--- branches/std/src/world_entities/terrain.cc	(revision 7215)
+++ branches/std/src/world_entities/terrain.cc	(revision 7216)
@@ -48,6 +48,6 @@
     this->loadParams(root);
 
-//  if (this->model != NULL)
-    //this->ssp = new SpatialSeparation((Model*)this->model, 10.0f);
+  //  if (this->model != NULL)
+  //this->ssp = new SpatialSeparation((Model*)this->model, 10.0f);
 }
 
@@ -64,11 +64,11 @@
 
   if (!strstr(fileName, ".obj") || !strstr(fileName, ".OBJ") )
-    {
-      this->loadModel(fileName);
-    }
+  {
+    this->loadModel(fileName);
+  }
   else
-    {
-      // load the hightMap here.
-    }
+  {
+    // load the hightMap here.
+  }
 }
 
@@ -98,5 +98,5 @@
 
   if(this->heightMap)
-        delete heightMap;
+    delete heightMap;
 }
 
@@ -122,14 +122,14 @@
 
   LoadParam(root, "scale", this, Terrain, setScale)
-      .describe("The scale in x,y,z direction");
+  .describe("The scale in x,y,z direction");
 
   LoadParam(root, "texture", this, Terrain, loadTexture)
-      .describe("The name of the Texture for this heightMap");
+  .describe("The name of the Texture for this heightMap");
 
   LoadParam(root, "vegetation", this, Terrain, loadVegetation)
-      .describe("the fileName of the vegetation, that should be loaded onto this terrain. (must be relative to the data-dir)") ;
+  .describe("the fileName of the vegetation, that should be loaded onto this terrain. (must be relative to the data-dir)") ;
 
   LoadParam(root, "height-map", this, Terrain, loadHeightMap)
-      .describe("The HeightMap, splitted into two strings seperated by ','. 1: HeighMap, 2: ColorMap");
+  .describe("The HeightMap, splitted into two strings seperated by ','. 1: HeighMap, 2: ColorMap");
 
 }
@@ -140,5 +140,5 @@
 }
 
-void Terrain::loadHeightMap(const char* heightMapFile, const char* colorMap)
+void Terrain::loadHeightMap(const std::string& heightMapFile, const std::string& colorMap)
 {
   if (this->heightMap != NULL)
@@ -151,5 +151,5 @@
 
   this->heightMap = new HeightMap(hmName, hmColorName);
-//   heightMap->scale(Vector(43.0f,4.7f,43.0f));
+  //   heightMap->scale(Vector(43.0f,4.7f,43.0f));
   heightMap->scale(this->terrainScale);
   heightMap->setAbsCoor(this->getAbsCoor());
@@ -158,17 +158,17 @@
 
 
-void Terrain::loadTexture(const char* textureName)
-{
-   PRINTF(0)("Load texture: %s\n", textureName);
-
-   heightMapMaterial->setDiffuse(1.0,1.0,1.0);
-   heightMapMaterial->setAmbient(1.0,1.0,1.0 );
-   heightMapMaterial->setSpecular(1.0,1.0,1.0);
-   heightMapMaterial->setShininess(.5);
-   heightMapMaterial->setTransparency(1.0);
-
-   heightMapMaterial->setDiffuseMap(textureName);
-   heightMapMaterial->setAmbientMap(textureName);
-   heightMapMaterial->setSpecularMap(textureName);
+void Terrain::loadTexture(const std::string& textureName)
+{
+  PRINTF(4)("Load texture: %s\n", textureName.c_str());
+
+  heightMapMaterial->setDiffuse(1.0,1.0,1.0);
+  heightMapMaterial->setAmbient(1.0,1.0,1.0 );
+  heightMapMaterial->setSpecular(1.0,1.0,1.0);
+  heightMapMaterial->setShininess(.5);
+  heightMapMaterial->setTransparency(1.0);
+
+  heightMapMaterial->setDiffuseMap(textureName);
+  //   heightMapMaterial->setAmbientMap(textureName);
+  //   heightMapMaterial->setSpecularMap(textureName);
 }
 
@@ -202,5 +202,5 @@
                 this->getAbsCoor ().z);
   /* rotate */
- // Vector tmpRot = this->getAbsDir().getSpacialAxis();
+  // Vector tmpRot = this->getAbsDir().getSpacialAxis();
   //glRotatef (this->getAbsDir().getSpacialAxisAngle(), tmpRot.x, tmpRot.y, tmpRot.z );
 
@@ -224,25 +224,25 @@
 
 
-/*
-  glMatrixMode(GL_MODELVIEW);
-  glPushMatrix();
-  glLoadIdentity();
-  Vector camera =   State::getCameraNode()->getAbsCoor(); // Go on here ..........!!!
-
-  float height =    heightMap->getHeight(camera.x, camera.z);
-
-  glEnable (GL_COLOR_MATERIAL) ;
-  glBegin(GL_QUADS);            // Draw The Cube Using quads
-  glColor3f(0.0f,1.0f,0.0f);  // Color Blue
-  glVertex3f(camera.x + 63.0f,Terrain->getHeight(camera.x+63.0f, camera.z-10.0f)+13.0f,camera.z-10.0f);      // Top Right Of The Quad (Top)
-  glVertex3f(camera.x-63.0f, getHeight(camera.x+63.0f, camera.z-10.0f)+13.0f,camera.z-10.0f);      // Top Left Of The Quad (Top)
-  glVertex3f(camera.x-63.0f, getHeight(camera.x+63.0f, camera.z+10.0f)+13.0f, camera.z+10.0f);      // Bottom Left Of The Quad (Top)
-  glVertex3f(camera.x+ 63.0f, getHeight(camera.x+63.0f, camera.z+10.0f)+13.0f, camera.z+10.0f);      // Bottom Right Of The Quad (Top)
-  glEnd();                      // End Drawing The Plan
-
-  glPopMatrix();*/
-
-
-/* THIS IS ONLY FOR DEBUGGING INFORMATION */
+  /*
+    glMatrixMode(GL_MODELVIEW);
+    glPushMatrix();
+    glLoadIdentity();
+    Vector camera =   State::getCameraNode()->getAbsCoor(); // Go on here ..........!!!
+
+    float height =    heightMap->getHeight(camera.x, camera.z);
+
+    glEnable (GL_COLOR_MATERIAL) ;
+    glBegin(GL_QUADS);            // Draw The Cube Using quads
+    glColor3f(0.0f,1.0f,0.0f);  // Color Blue
+    glVertex3f(camera.x + 63.0f,Terrain->getHeight(camera.x+63.0f, camera.z-10.0f)+13.0f,camera.z-10.0f);      // Top Right Of The Quad (Top)
+    glVertex3f(camera.x-63.0f, getHeight(camera.x+63.0f, camera.z-10.0f)+13.0f,camera.z-10.0f);      // Top Left Of The Quad (Top)
+    glVertex3f(camera.x-63.0f, getHeight(camera.x+63.0f, camera.z+10.0f)+13.0f, camera.z+10.0f);      // Bottom Left Of The Quad (Top)
+    glVertex3f(camera.x+ 63.0f, getHeight(camera.x+63.0f, camera.z+10.0f)+13.0f, camera.z+10.0f);      // Bottom Right Of The Quad (Top)
+    glEnd();                      // End Drawing The Plan
+
+    glPopMatrix();*/
+
+
+  /* THIS IS ONLY FOR DEBUGGING INFORMATION */
   if (this->ssp != NULL)
     this->ssp->drawQuadtree();
@@ -254,163 +254,171 @@
   // if the terrain is the Terrain of Dave
   if (debugTerrain == TERRAIN_DAVE)
-    {
-      objectList = glGenLists(1);
-      glNewList (objectList, GL_COMPILE);
-
-      glColor3f(1.0,0,0);
-
-      int sizeX = 100;
-      int sizeZ = 80;
-      float length = 1000;
-      float width = 200;
-      float widthX = float (length /sizeX);
-      float widthZ = float (width /sizeZ);
-
-      float height [sizeX][sizeZ];
-      Vector normal_vectors[sizeX][sizeZ];
-
-
-      for ( int i = 0; i<sizeX-1; i+=1)
-        for (int j = 0; j<sizeZ-1;j+=1)
-          //height[i][j] = rand()/20046 + (j-25)*(j-25)/30;
+  {
+    objectList = glGenLists(1);
+    glNewList (objectList, GL_COMPILE);
+
+    glColor3f(1.0,0,0);
+
+    int sizeX = 100;
+    int sizeZ = 80;
+    float length = 1000;
+    float width = 200;
+    float widthX = float (length /sizeX);
+    float widthZ = float (width /sizeZ);
+
+    float height [sizeX][sizeZ];
+    Vector normal_vectors[sizeX][sizeZ];
+
+
+    for ( int i = 0; i<sizeX-1; i+=1)
+      for (int j = 0; j<sizeZ-1;j+=1)
+        //height[i][j] = rand()/20046 + (j-25)*(j-25)/30;
 #ifdef __WIN32__
-          height[i][j]=(sin((float)j/3)*rand()*i/182400)*.5;
+        height[i][j]=(sin((float)j/3)*rand()*i/182400)*.5;
 #else
-      height[i][j]=(sin((float)j/3)*rand()*(long)i/6282450500.0)*.5;
+        height[i][j]=(sin((float)j/3)*rand()*(long)i/6282450500.0)*.5;
 #endif
 
-      //Die Huegel ein wenig glaetten
-      for (int h=1; h<2;h++)
-        for (int i=1;i<sizeX-2 ;i+=1 )
-          for(int j=1;j<sizeZ-2;j+=1)
-            height[i][j]=(height[i+1][j]+height[i][j+1]+height[i-1][j]+height[i][j-1])/4;
-
-      //Berechnung von normalen Vektoren
-      for(int i=1;i<sizeX-2;i+=1)
-        for(int j=1;j<sizeZ-2 ;j+=1)
-          {
-            Vector v1 = Vector (widthX*(1),      height[i][j],      widthZ*(j) );
-            Vector v2 = Vector (widthX*(i-1),    height[i-1][j],    widthZ*(j));
-            Vector v3 = Vector (widthX*(i),      height[i][j+1],    widthZ*(j+1));
-            Vector v4 = Vector (widthX*(i+1),    height[i+1][j],    widthZ*(j));
-            Vector v5 = Vector (widthX*(i),      height[i][j-1],    widthZ*(j-1));
-
-            Vector c1 = v2 - v1;
-            Vector c2 = v3 - v1;
-            Vector c3=  v4 - v1;
-            Vector c4 = v5 - v1;
-            Vector zero = Vector (0,0,0);
-            normal_vectors[i][j]=c1.cross(v3-v5)+c2.cross(v4-v2)+c3.cross(v5-v3)+c4.cross(v2-v4);
-            normal_vectors[i][j].normalize();
-          }
-
-      glBegin(GL_QUADS);
-      int snowheight=3;
-      for ( int i = 0; i<sizeX; i+=1)
-        for (int j = 0; j<sizeZ;j+=1)
-          {
-            Vector v1 = Vector (widthX*(i),      height[i][j]-20,       widthZ*(j)  -width/2);
-            Vector v2 = Vector (widthX*(i+1),    height[i+1][j]-20,     widthZ*(j)  -width/2);
-            Vector v3 = Vector (widthX*(i+1),    height[i+1][j+1]-20,   widthZ*(j+1)-width/2);
-            Vector v4 = Vector (widthX*(i),      height[i][j+1]-20,     widthZ*(j+1)-width/2);
-            float a[3];
-            if(height[i][j]<snowheight){
-              a[0]=0;
-              a[1]=1.0-height[i][j]/10-.3;
-              a[2]=0;
-              glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
-            }
-            else{
-              a[0]=1.0;
-              a[1]=1.0;
-              a[2]=1.0;
-              glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
-
-            }
-            glNormal3f(normal_vectors[i][j].x, normal_vectors[i][j].y, normal_vectors[i][j].z);
-            glVertex3f(v1.x, v1.y, v1.z);
-            if(height[i+1][j]<snowheight){
-              a[0]=0;
-              a[1] =1.0-height[i+1][j]/10-.3;
-              a[2]=0;
-              glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
-            }
-            else{
-              a[0]=1.0;
-              a[1]=1.0;
-              a[2]=1.0;
-              glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
-
-            }
-            glNormal3f(normal_vectors[i+1][j].x, normal_vectors[i+1][j].y, normal_vectors[i+1][j].z);
-            glVertex3f(v2.x, v2.y, v2.z);
-            if(height[i+1][j+1]<snowheight){
-              a[0]=0;
-              a[1] =1.0-height[i+1][j+1]/10-.3;
-              a[2]=0;
-              glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
-            }
-            else{
-              a[0]=1.0;
-              a[1]=1.0;
-              a[2]=1.0;
-              glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
-
-
-            }
-            glNormal3f(normal_vectors[i+1][j+1].x, normal_vectors[i+1][j+1].y, normal_vectors[i+1][j+1].z);
-            glVertex3f(v3.x, v3.y, v3.z);
-            if(height[i][j+1]<snowheight){
-              a[0]=0;
-              a[1] =1.0-height[i+1][j+1]/10-.3;
-              a[2]=0;
-              glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
-            }
-            else{
-              a[0]=1.0;
-              a[1]=1.0;
-              a[2]=1.0;
-              glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
-            }
-            glNormal3f(normal_vectors[i][j+1].x, normal_vectors[i][j+1].y, normal_vectors[i][j+1].z);
-            glVertex3f(v4.x, v4.y, v4.z);
-
-          }
-      glEnd();
-      glEndList();
-    }
+    //Die Huegel ein wenig glaetten
+    for (int h=1; h<2;h++)
+      for (int i=1;i<sizeX-2 ;i+=1 )
+        for(int j=1;j<sizeZ-2;j+=1)
+          height[i][j]=(height[i+1][j]+height[i][j+1]+height[i-1][j]+height[i][j-1])/4;
+
+    //Berechnung von normalen Vektoren
+    for(int i=1;i<sizeX-2;i+=1)
+      for(int j=1;j<sizeZ-2 ;j+=1)
+      {
+        Vector v1 = Vector (widthX*(1),      height[i][j],      widthZ*(j) );
+        Vector v2 = Vector (widthX*(i-1),    height[i-1][j],    widthZ*(j));
+        Vector v3 = Vector (widthX*(i),      height[i][j+1],    widthZ*(j+1));
+        Vector v4 = Vector (widthX*(i+1),    height[i+1][j],    widthZ*(j));
+        Vector v5 = Vector (widthX*(i),      height[i][j-1],    widthZ*(j-1));
+
+        Vector c1 = v2 - v1;
+        Vector c2 = v3 - v1;
+        Vector c3=  v4 - v1;
+        Vector c4 = v5 - v1;
+        Vector zero = Vector (0,0,0);
+        normal_vectors[i][j]=c1.cross(v3-v5)+c2.cross(v4-v2)+c3.cross(v5-v3)+c4.cross(v2-v4);
+        normal_vectors[i][j].normalize();
+      }
+
+    glBegin(GL_QUADS);
+    int snowheight=3;
+    for ( int i = 0; i<sizeX; i+=1)
+      for (int j = 0; j<sizeZ;j+=1)
+      {
+        Vector v1 = Vector (widthX*(i),      height[i][j]-20,       widthZ*(j)  -width/2);
+        Vector v2 = Vector (widthX*(i+1),    height[i+1][j]-20,     widthZ*(j)  -width/2);
+        Vector v3 = Vector (widthX*(i+1),    height[i+1][j+1]-20,   widthZ*(j+1)-width/2);
+        Vector v4 = Vector (widthX*(i),      height[i][j+1]-20,     widthZ*(j+1)-width/2);
+        float a[3];
+        if(height[i][j]<snowheight)
+        {
+          a[0]=0;
+          a[1]=1.0-height[i][j]/10-.3;
+          a[2]=0;
+          glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
+        }
+        else
+        {
+          a[0]=1.0;
+          a[1]=1.0;
+          a[2]=1.0;
+          glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
+
+        }
+        glNormal3f(normal_vectors[i][j].x, normal_vectors[i][j].y, normal_vectors[i][j].z);
+        glVertex3f(v1.x, v1.y, v1.z);
+        if(height[i+1][j]<snowheight)
+        {
+          a[0]=0;
+          a[1] =1.0-height[i+1][j]/10-.3;
+          a[2]=0;
+          glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
+        }
+        else
+        {
+          a[0]=1.0;
+          a[1]=1.0;
+          a[2]=1.0;
+          glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
+
+        }
+        glNormal3f(normal_vectors[i+1][j].x, normal_vectors[i+1][j].y, normal_vectors[i+1][j].z);
+        glVertex3f(v2.x, v2.y, v2.z);
+        if(height[i+1][j+1]<snowheight)
+        {
+          a[0]=0;
+          a[1] =1.0-height[i+1][j+1]/10-.3;
+          a[2]=0;
+          glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
+        }
+        else
+        {
+          a[0]=1.0;
+          a[1]=1.0;
+          a[2]=1.0;
+          glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
+
+
+        }
+        glNormal3f(normal_vectors[i+1][j+1].x, normal_vectors[i+1][j+1].y, normal_vectors[i+1][j+1].z);
+        glVertex3f(v3.x, v3.y, v3.z);
+        if(height[i][j+1]<snowheight)
+        {
+          a[0]=0;
+          a[1] =1.0-height[i+1][j+1]/10-.3;
+          a[2]=0;
+          glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
+        }
+        else
+        {
+          a[0]=1.0;
+          a[1]=1.0;
+          a[2]=1.0;
+          glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
+        }
+        glNormal3f(normal_vectors[i][j+1].x, normal_vectors[i][j+1].y, normal_vectors[i][j+1].z);
+        glVertex3f(v4.x, v4.y, v4.z);
+
+      }
+    glEnd();
+    glEndList();
+  }
 
   if (debugTerrain == TERRAIN_BENSCH)
-    {
-      /*
-        this->model = (OBJModel*) new Model();
-      this->model->setName("CUBE");
-      this->model->addVertex (-0.5, -0.5, 0.5);
-      this->model->addVertex (0.5, -0.5, 0.5);
-      this->model->addVertex (-0.5, 0.5, 0.5);
-      this->model->addVertex (0.5, 0.5, 0.5);
-      this->model->addVertex (-0.5, 0.5, -0.5);
-      this->model->addVertex (0.5, 0.5, -0.5);
-      this->model->addVertex (-0.5, -0.5, -0.5);
-      this->model->addVertex (0.5, -0.5, -0.5);
-
-      this->model->addVertexTexture (0.0, 0.0);
-      this->model->addVertexTexture (1.0, 0.0);
-      this->model->addVertexTexture (0.0, 1.0);
-      this->model->addVertexTexture (1.0, 1.0);
-      this->model->addVertexTexture (0.0, 2.0);
-      this->model->addVertexTexture (1.0, 2.0);
-      this->model->addVertexTexture (0.0, 3.0);
-      this->model->addVertexTexture (1.0, 3.0);
-      this->model->addVertexTexture (0.0, 4.0);
-      this->model->addVertexTexture (1.0, 4.0);
-      this->model->addVertexTexture (2.0, 0.0);
-      this->model->addVertexTexture (2.0, 1.0);
-      this->model->addVertexTexture (-1.0, 0.0);
-      this->model->addVertexTexture (-1.0, 1.0);
-
-      this->model->finalize();
-      */
-    }
+  {
+    /*
+      this->model = (OBJModel*) new Model();
+    this->model->setName("CUBE");
+    this->model->addVertex (-0.5, -0.5, 0.5);
+    this->model->addVertex (0.5, -0.5, 0.5);
+    this->model->addVertex (-0.5, 0.5, 0.5);
+    this->model->addVertex (0.5, 0.5, 0.5);
+    this->model->addVertex (-0.5, 0.5, -0.5);
+    this->model->addVertex (0.5, 0.5, -0.5);
+    this->model->addVertex (-0.5, -0.5, -0.5);
+    this->model->addVertex (0.5, -0.5, -0.5);
+
+    this->model->addVertexTexture (0.0, 0.0);
+    this->model->addVertexTexture (1.0, 0.0);
+    this->model->addVertexTexture (0.0, 1.0);
+    this->model->addVertexTexture (1.0, 1.0);
+    this->model->addVertexTexture (0.0, 2.0);
+    this->model->addVertexTexture (1.0, 2.0);
+    this->model->addVertexTexture (0.0, 3.0);
+    this->model->addVertexTexture (1.0, 3.0);
+    this->model->addVertexTexture (0.0, 4.0);
+    this->model->addVertexTexture (1.0, 4.0);
+    this->model->addVertexTexture (2.0, 0.0);
+    this->model->addVertexTexture (2.0, 1.0);
+    this->model->addVertexTexture (-1.0, 0.0);
+    this->model->addVertexTexture (-1.0, 1.0);
+
+    this->model->finalize();
+    */
+  }
 }
 
@@ -450,15 +458,13 @@
 
 void Terrain::writeDebug( ) const
-{
-}
+  {}
 
 void Terrain::readDebug( ) const
-{
-}
+  {}
 
 float Terrain::getHeight(float x, float y)
 {
-        if(this->heightMap != NULL)
-                return (this->heightMap->getHeight(x, y));
-        return 0;
-}
+  if(this->heightMap != NULL)
+    return (this->heightMap->getHeight(x, y));
+  return 0;
+}
Index: branches/std/src/world_entities/terrain.h
===================================================================
--- branches/std/src/world_entities/terrain.h	(revision 7215)
+++ branches/std/src/world_entities/terrain.h	(revision 7216)
@@ -43,6 +43,6 @@
   void loadVegetation(const std::string& vegetationFile);
 
-  void loadHeightMap(const char* heightMapFile, const char* colorMap = NULL);
-  void loadTexture(const char* textureName);
+  void loadHeightMap(const std::string& heightMapFile, const std::string& colorMap);
+  void loadTexture(const std::string& textureName);
   void setScale(float x, float y, float z);
 
Index: branches/std/src/world_entities/weapons/aim.cc
===================================================================
--- branches/std/src/world_entities/weapons/aim.cc	(revision 7215)
+++ branches/std/src/world_entities/weapons/aim.cc	(revision 7216)
@@ -147,5 +147,5 @@
  * @param textureFile The texture-file to load onto the crosshair
  */
-void Aim::setTexture(const char* textureFile)
+void Aim::setTexture(const std::string& textureFile)
 {
   this->material->setDiffuseMap(textureFile);
Index: branches/std/src/world_entities/weapons/aim.h
===================================================================
--- branches/std/src/world_entities/weapons/aim.h	(revision 7215)
+++ branches/std/src/world_entities/weapons/aim.h	(revision 7216)
@@ -46,5 +46,5 @@
 
   void setSize(float size);
-  void setTexture(const char* textureFile);
+  void setTexture(const std::string& textureFile);
   /** @param rotationSpeed the speed at what the crosshair should rotate */
   inline void setRotationSpeed(float rotationSpeed) { this->rotationSpeed = rotationSpeed; };
Index: branches/std/src/world_entities/weapons/crosshair.cc
===================================================================
--- branches/std/src/world_entities/weapons/crosshair.cc	(revision 7215)
+++ branches/std/src/world_entities/weapons/crosshair.cc	(revision 7216)
@@ -79,5 +79,5 @@
   EventListener::loadParams(root);
 
-  LoadParam(root, "texture", this, Crosshair, setTexture)
+  LoadParam(root, "texture", this->material, Material, setDiffuseMap)
       .describe("the texture-file to load onto the Crosshair");
 
@@ -103,5 +103,5 @@
  * @param textureFile The texture-file to load onto the crosshair
  */
-void Crosshair::setTexture(const char* textureFile)
+void Crosshair::setTexture(const std::string& textureFile)
 {
   this->material->setDiffuseMap(textureFile);
Index: branches/std/src/world_entities/weapons/crosshair.h
===================================================================
--- branches/std/src/world_entities/weapons/crosshair.h	(revision 7215)
+++ branches/std/src/world_entities/weapons/crosshair.h	(revision 7216)
@@ -31,5 +31,5 @@
 
   void setSize(float size);
-  void setTexture(const char* textureFile);
+  void setTexture(const std::string& textureFile);
   /** @param rotationSpeed the speed at what the crosshair should rotate */
   void setRotationSpeed(float rotationSpeed) { this->rotationSpeed = rotationSpeed; };
Index: branches/std/src/world_entities/weapons/weapon.cc
===================================================================
--- branches/std/src/world_entities/weapons/weapon.cc	(revision 7215)
+++ branches/std/src/world_entities/weapons/weapon.cc	(revision 7216)
@@ -165,8 +165,6 @@
  * @param projectile the Name of the Projectile.
  */
-void Weapon::setProjectileTypeC(const char* projectile)
-{
-  if (projectile == NULL)
-    return;
+void Weapon::setProjectileTypeC(const std::string& projectile)
+{
   FastFactory* tmpFac = FastFactory::searchFastFactory(projectile);
   if (tmpFac != NULL)
@@ -176,5 +174,5 @@
   else
   {
-    PRINTF(1)("Projectile %s does not exist for weapon %s\n", projectile, this->getName());
+    PRINTF(1)("Projectile %s does not exist for weapon %s\n", projectile.c_str(), this->getName());
   }
 }
@@ -613,23 +611,23 @@
  * @return The Action if known, WA_NONE otherwise.
  */
-WeaponAction Weapon::charToAction(const char* action)
-{
-  if (!strcmp(action, "none"))
+WeaponAction Weapon::charToAction(const std::string& action)
+{
+  if (action == "none")
     return WA_NONE;
-  else if (!strcmp(action, "shoot"))
+  else if (action == "shoot")
     return WA_SHOOT;
-  else if (!strcmp(action, "charge"))
+  else if (action == "charge")
     return WA_CHARGE;
-  else if (!strcmp(action, "reload"))
+  else if (action == "reload")
     return WA_RELOAD;
-  else if (!strcmp(action, "acitvate"))
+  else if (action == "acitvate")
     return WA_ACTIVATE;
-  else if (!strcmp(action, "deactivate"))
+  else if (action == "deactivate")
     return WA_DEACTIVATE;
-  else if (!strcmp(action, "special1"))
+  else if (action == "special1")
     return WA_SPECIAL1;
   else
   {
-    PRINTF(2)("action %s could not be identified.\n", action);
+    PRINTF(2)("action %s could not be identified.\n", action.c_str());
     return WA_NONE;
   }
@@ -674,25 +672,25 @@
  * @return The State if known, WS_NONE otherwise.
  */
-WeaponState Weapon::charToState(const char* state)
-{
-  if (!strcmp(state, "none"))
+WeaponState Weapon::charToState(const std::string& state)
+{
+  if (state == "none")
     return WS_NONE;
-  else if (!strcmp(state, "shooting"))
+  else if (state == "shooting")
     return WS_SHOOTING;
-  else if (!strcmp(state, "charging"))
+  else if (state == "charging")
     return WS_CHARGING;
-  else if (!strcmp(state, "reloading"))
+  else if (state == "reloading")
     return WS_RELOADING;
-  else if (!strcmp(state, "activating"))
+  else if (state == "activating")
     return WS_ACTIVATING;
-  else if (!strcmp(state, "deactivating"))
+  else if (state == "deactivating")
     return WS_DEACTIVATING;
-  else if (!strcmp(state, "inactive"))
+  else if (state == "inactive")
     return WS_INACTIVE;
-  else if (!strcmp(state, "idle"))
+  else if (state == "idle")
     return WS_IDLE;
   else
   {
-    PRINTF(2)("state %s could not be identified.\n", state);
+    PRINTF(2)("state %s could not be identified.\n", state.c_str());
     return WS_NONE;
   }
Index: branches/std/src/world_entities/weapons/weapon.h
===================================================================
--- branches/std/src/world_entities/weapons/weapon.h	(revision 7215)
+++ branches/std/src/world_entities/weapons/weapon.h	(revision 7216)
@@ -111,5 +111,5 @@
     inline long getCapability() const { return this->capability; };
     void setProjectileType(ClassID projectile);
-    void setProjectileTypeC(const char* projectile);
+    void setProjectileTypeC(const std::string& projectile);
     /** @returns The projectile's classID */
     inline ClassID getProjectileType() { return this->projectile; };
@@ -132,5 +132,5 @@
     // STATE CHANGES //
     /** @param state the State to time @param duration the duration of the State */
-    inline void setStateDuration(const char* state, float duration) { setStateDuration(charToState(state), duration); };
+    inline void setStateDuration(const std::string& state, float duration) { setStateDuration(charToState(state), duration); };
     /** @param state the State to time @param duration the duration of the State */
     inline void setStateDuration(WeaponState state, float duration) { /*(state < WS_STATE_COUNT)?*/this->times[state] = duration; };
@@ -149,6 +149,6 @@
 
     void setActionSound(WeaponAction action, const std::string& soundFile);
-    /** @see void setActionSound(WeaponAction action, const char* soundFile); */
-    void setActionSound(const char* action, const char* soundFile) { this->setActionSound(charToAction(action), soundFile); };
+    /** @see void setActionSound(WeaponAction action, const std::string& soundFile); */
+    void setActionSound(const std::string& action, const std::string& soundFile) { this->setActionSound(charToAction(action), soundFile); };
 
     Animation3D* getAnimation(WeaponState state, PNode* node = NULL);
@@ -176,7 +176,7 @@
 
     // utility:
-    static WeaponAction  charToAction(const char* action);
+    static WeaponAction  charToAction(const std::string& action);
     static const char*   actionToChar(WeaponAction action);
-    static WeaponState   charToState(const char* state);
+    static WeaponState   charToState(const std::string& state);
     static const char*   stateToChar(WeaponState state);
 
Index: branches/std/src/world_entities/world_entity.cc
===================================================================
--- branches/std/src/world_entities/world_entity.cc	(revision 7215)
+++ branches/std/src/world_entities/world_entity.cc	(revision 7216)
@@ -61,6 +61,4 @@
   this->bCollide = true;
 
-  this->md2TextureFileName = NULL;
-
   this->objectListNumber = OM_INIT;
   this->objectListIterator = NULL;
@@ -123,20 +121,19 @@
  * @todo fix this, so it only has one loadModel-Function.
 */
-void WorldEntity::loadModel(const char* fileName, float scaling, unsigned int modelNumber)
+void WorldEntity::loadModel(const std::string& fileName, float scaling, unsigned int modelNumber)
 {
   this->modelLODName = fileName;
   this->scaling = scaling;
-  if ( fileName != NULL && strcmp(fileName, "") )
+  if (!fileName.empty())
   {
     // search for the special character # in the LoadParam
-    if (strchr(fileName, '#') != NULL)
-    {
-      PRINTF(4)("Found # in %s... searching for LOD's\n", fileName);
-      char* lodFile = new char[strlen(fileName)+1];
-      strcpy(lodFile, fileName);
-      char* depth = strchr(lodFile, '#');
+    if (fileName.find('#') != std::string::npos)
+    {
+      PRINTF(4)("Found # in %s... searching for LOD's\n", fileName.c_str());
+      std::string lodFile = fileName;
+      unsigned int offset = lodFile.find('#');
       for (unsigned int i = 0; i < 3; i++)
       {
-        *depth = 48+(int)i;
+        lodFile[offset] = 48+(int)i;
         if (ResourceManager::isInDataDir(lodFile))
           this->loadModel(lodFile, scaling, i);
@@ -149,7 +146,7 @@
       this->scaling = 1.0;
     }
-    if(strstr(fileName, ".obj"))
-    {
-      PRINTF(4)("fetching OBJ file: %s\n", fileName);
+    if(fileName.find(".obj") != std::string::npos)
+    {
+      PRINTF(4)("fetching OBJ file: %s\n", fileName.c_str());
       BaseObject* loadedModel = ResourceManager::getInstance()->load(fileName, OBJ, RP_CAMPAIGN, this->scaling);
       if (loadedModel != NULL)
@@ -159,7 +156,7 @@
         this->buildObbTree(4);
     }
-    else if(strstr(fileName, ".md2"))
-    {
-      PRINTF(4)("fetching MD2 file: %s\n", fileName);
+    else if(fileName.find(".md2") != std::string::npos)
+    {
+      PRINTF(4)("fetching MD2 file: %s\n", fileName.c_str());
       Model* m = new MD2Model(fileName, this->md2TextureFileName, this->scaling);
       //this->setModel((Model*)ResourceManager::getInstance()->load(fileName, MD2, RP_CAMPAIGN), 0);
Index: branches/std/src/world_entities/world_entity.h
===================================================================
--- branches/std/src/world_entities/world_entity.h	(revision 7215)
+++ branches/std/src/world_entities/world_entity.h	(revision 7216)
@@ -36,9 +36,9 @@
   virtual void loadParams(const TiXmlElement* root);
 
-  void loadModel(const char* fileName, float scaling = 1.0f, unsigned int modelNumber = 0);
+  void loadModel(const std::string& fileName, float scaling = 1.0f, unsigned int modelNumber = 0);
   void setModel(Model* model, unsigned int modelNumber = 0);
   Model* getModel(unsigned int modelNumber = 0) const { return (this->models.size() > modelNumber)? this->models[modelNumber] : NULL; };
 
-  inline void loadMD2Texture(const char* fileName) { this->md2TextureFileName = fileName; }
+  inline void loadMD2Texture(const std::string& fileName) { this->md2TextureFileName = fileName; }
 
   bool buildObbTree(unsigned int depth);
@@ -113,6 +113,6 @@
 
   std::vector<Model*>     models;             //!< The model that should be loaded for this entity.
-  const char*             md2TextureFileName; //!< the file name of the md2 model texture, only if this
-  const char*             modelLODName;       //!< the name of the model lod file
+  std::string             md2TextureFileName; //!< the file name of the md2 model texture, only if this
+  std::string             modelLODName;       //!< the name of the model lod file
   BVTree*                 obbTree;            //!< this is the obb tree reference needed for collision detection
 
