Index: /orxonox/trunk/src/Makefile.am
===================================================================
--- /orxonox/trunk/src/Makefile.am	(revision 2076)
+++ /orxonox/trunk/src/Makefile.am	(revision 2077)
@@ -6,5 +6,5 @@
 
 bin_PROGRAMS=orxonox
-orxonox_SOURCES=orxonox.cc world.cc environment.cc player.cc npc.cc input_output.cc data_tank.cc ai.cc shoot_laser.cc shoot_rocket.cc world_entity.cc synchronisable.cc list.cc vector.cc ability.cc
+orxonox_SOURCES=orxonox.cc world.cc environment.cc player.cc npc.cc input_output.cc data_tank.cc ai.cc shoot_laser.cc shoot_rocket.cc world_entity.cc synchronisable.cc vector.cc ability.cc power_up.cc
 
 #  uncomment the following if bencoder requires the math library
Index: /orxonox/trunk/src/Makefile.in
===================================================================
--- /orxonox/trunk/src/Makefile.in	(revision 2076)
+++ /orxonox/trunk/src/Makefile.in	(revision 2077)
@@ -117,5 +117,5 @@
 #"-O3 -pedantic -fPIC -ffast-math -I/usr/X11R6/include"
 bin_PROGRAMS = orxonox
-orxonox_SOURCES = orxonox.cc world.cc environment.cc player.cc npc.cc input_output.cc data_tank.cc ai.cc shoot_laser.cc shoot_rocket.cc world_entity.cc synchronisable.cc list.cc vector.cc ability.cc
+orxonox_SOURCES = orxonox.cc world.cc environment.cc player.cc npc.cc input_output.cc data_tank.cc ai.cc shoot_laser.cc shoot_rocket.cc world_entity.cc synchronisable.cc vector.cc ability.cc power_up.cc
 subdir = src
 ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
@@ -130,6 +130,6 @@
 	input_output.$(OBJEXT) data_tank.$(OBJEXT) ai.$(OBJEXT) \
 	shoot_laser.$(OBJEXT) shoot_rocket.$(OBJEXT) \
-	world_entity.$(OBJEXT) synchronisable.$(OBJEXT) list.$(OBJEXT) \
-	vector.$(OBJEXT) ability.$(OBJEXT)
+	world_entity.$(OBJEXT) synchronisable.$(OBJEXT) \
+	vector.$(OBJEXT) ability.$(OBJEXT) power_up.$(OBJEXT)
 orxonox_OBJECTS = $(am_orxonox_OBJECTS)
 orxonox_LDADD = $(LDADD)
@@ -142,7 +142,7 @@
 @AMDEP_TRUE@DEP_FILES = ./$(DEPDIR)/ability.Po ./$(DEPDIR)/ai.Po \
 @AMDEP_TRUE@	./$(DEPDIR)/data_tank.Po ./$(DEPDIR)/environment.Po \
-@AMDEP_TRUE@	./$(DEPDIR)/input_output.Po ./$(DEPDIR)/list.Po \
-@AMDEP_TRUE@	./$(DEPDIR)/npc.Po ./$(DEPDIR)/orxonox.Po \
-@AMDEP_TRUE@	./$(DEPDIR)/player.Po ./$(DEPDIR)/shoot_laser.Po \
+@AMDEP_TRUE@	./$(DEPDIR)/input_output.Po ./$(DEPDIR)/npc.Po \
+@AMDEP_TRUE@	./$(DEPDIR)/orxonox.Po ./$(DEPDIR)/player.Po \
+@AMDEP_TRUE@	./$(DEPDIR)/power_up.Po ./$(DEPDIR)/shoot_laser.Po \
 @AMDEP_TRUE@	./$(DEPDIR)/shoot_rocket.Po \
 @AMDEP_TRUE@	./$(DEPDIR)/synchronisable.Po ./$(DEPDIR)/vector.Po \
@@ -205,8 +205,8 @@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/environment.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/input_output.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/list.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/npc.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/orxonox.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/player.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/power_up.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/shoot_laser.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/shoot_rocket.Po@am__quote@
Index: xonox/trunk/src/list.cc
===================================================================
--- /orxonox/trunk/src/list.cc	(revision 2076)
+++ 	(revision )
@@ -1,74 +1,0 @@
-
-
-/* 
-   orxonox - the future of 3D-vertical-scrollers
-
-   Copyright (C) 2004 orx
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2, or (at your option)
-   any later version.
-
-   ### File Specific:
-   main-programmer: Patrick Boenzli
-   co-programmer: 
-*/
-
-#include "world_entity.h"
-#include "stdincl.h"
-
-#include "list.h"
-
-using namespace std;
-
-
-
-List::List () 
-{
-  lastElement = null;
-  listSize = 0;
-}
-
-List::~List () 
-{}
-
-
-void List::addElement(WorldEntity* we) 
-{
-  listElement* newElement = new listElement;
-  newElement->we = we;
-  newElement->next = lastElement;
-  newElement->prev = null;
-  lastElement = newElement;
-  listSize++;
-}
-
-
-void List::removeElement(WorldEntity* we) 
-{
-  listElement* element = lastElement;
-  while(element->we != we)
-    {
-      element = element->next;
-    }
-  element->prev->next = element->next;
-  element->next->prev = element->prev;
-  delete element->we;
-}
-
-
-WorldEntity* List::getElement(int number) 
-{}
-
-int List::getNrOfElement(WorldEntity* we) 
-{}
-
-void List::defragment() 
-{}
-
-void List::flushList() 
-{}
-
-void List::killList() 
-{}
Index: /orxonox/trunk/src/list.h
===================================================================
--- /orxonox/trunk/src/list.h	(revision 2076)
+++ /orxonox/trunk/src/list.h	(revision 2077)
@@ -1,35 +1,266 @@
+/*!
+  \file list.h
+  \brief Contains a template for a doubly linked list
+*/
 
 #ifndef LIST_H
 #define LIST_H
 
-#include "list.h"
-
-class WorldEntity;
-
-class List {
-
+#include "stdlib.h"
+
+//! An enum to list all the modes available when adding an object to a List
+enum ADDMODE {LIST_ADD_NEXT, LIST_ADD_PREV, LIST_ADD_FIRST, LIST_ADD_LAST};
+//! An enum to list the two searching directions available when removing an object from a List
+enum FINDMODE {LIST_FIND_BW, LIST_FIND_FW};
+
+//! A generic doubly linked list
+template<class T> class List 
+{
+  T* object;
+  List<T>* next;
+  List<T>* prev;
+  bool bReference;
+  
  public:
-  List ();
+  List (T* obj, List<T>* n, List<T>* p, bool bRef);
   ~List ();
-
-  void addElement(WorldEntity* we);
-  void removeElement(WorldEntity* we);
-  WorldEntity* getElement(int number);
-  int getNrOfElement(WorldEntity* we);
-  void defragment();
-  void flushList();
-  void killList();
-  
- private:
-  struct listElement {
-    WorldEntity* we;
-    listElement* next;
-    listElement* prev;
-  };
-  listElement* lastElement;
-  int listSize;
-
-
+  
+  int add (T* obj, ADDMODE mode, bool bRef);
+  T* get_object();
+  List<T>* get_next ();
+  List<T>* get_previous ();
+  List<T>* get_last ();
+  List<T>* get_first ();
+  void set_next (List<T>* ptr);
+  void set_prev (List<T>* ptr);
+  int remove (T* obj, FINDMODE mode);
 };
 
+
+/**
+  \brief Standard constructor
+  
+  Call this without any parameters to generate a new List which can be filled with content.
+  DO NOT create a List element that contains an object on your own, you'll lose the data
+  contained in that object and will have trouble removing the list from your memory.
+*/
+template<class T>
+List<T>::List (T* obj = NULL, List<T>* n = NULL, List<T>* p = NULL, bool bRef = false)
+{
+  object = obj;
+  next = n;
+  prev = p;
+  bReference = bRef;
+}
+
+/**
+  \brief Standard destructor
+  
+  Call this on the initially generated base List element to remove the whole List from the memory.
+  You can safely do this to any List element you want without messing up the rest of the List, but keep in mind
+  that the contained object will be deleted as well when bRef had been set to false.
+*/
+template<class T>
+List<T>::~List ()
+{
+  if (object == NULL) // deleted foot node => disband the list
+  {
+    while( next != NULL)
+    {
+      delete next;
+    }
+    while( prev != NULL)
+    {
+      delete prev;
+    }
+  }
+  else
+  {
+    if (prev != NULL) prev->set_next (next);
+    if (next != NULL) next->set_prev (prev);
+    if (!bReference) delete object;
+  }
+}
+ 
+/**
+  \brief Add an object to the List
+  \param obj: A pointer to an allocated object
+  \param mode: A Value of ADDMODE (default: LIST_ADD_NEXT)
+  \param bRef: Sets whether the element is serving as a storage point or a simple listing (default: false)
+  \return 0 if the operation succeded, -1 if the element could not be added
+  
+  This adds a new List element to the chain. The mode parameter can be used to specify
+  the location where the element should be added. LIST_ADD_NEXT will add the new element directly
+  after the base element. LIST_ADD_PREV will add the new element directly before the base element.
+  LIST_ADD_FIRST will add the element at the beginning of the List whereas LIST_ADD_LAST will add
+  it to the end of the chain. If the bRef parameter is set to true, the object pointer will not be deleted
+  when the element containing that object is deleted, thus the List can be used for temporary listings as
+  well as permanent data storage.
+*/
+template<class T> 
+int List<T>::add (T* obj, ADDMODE mode = LIST_ADD_NEXT, bool bRef = false)
+{
+  List<T>* p;
+  if( obj == NULL) return -1;
+  switch (mode)
+  {
+    case LIST_ADD_NEXT:
+      p = new List<T>( obj, next, this, bRef);
+      if( next != NULL) next->set_prev (p);
+      next = p;
+      break;
+    case LIST_ADD_PREV:
+      p = new List<T>( obj, this, prev, bRef);
+      if( prev != NULL) prev->set_next (p);
+      prev = p;
+      break;
+    case LIST_ADD_FIRST:
+      if (prev == NULL) prev = new List<T> (obj, this, NULL, bRef);
+      else return prev->add (obj, mode, bRef);
+      break;
+    case LIST_ADD_LAST:
+      if (next == NULL) next = new List<T> (obj, NULL, this, bRef);
+      else return next->add (obj, mode, bRef);
+      break;
+    default:
+        return -1;
+      break;
+  }
+  return 0;
+}
+
+/**
+  \brief Get the next element of the List
+  \return The List element after the current List element
+*/
+template<class T>
+List<T>* List<T>::get_next ()
+{
+  return next;
+}
+ 
+/**
+  \brief Get the previous element of the List
+  \return The List element before the current List element
+*/
+template<class T>
+List<T>* List<T>::get_previous ()
+{
+  return prev;
+}
+
+/**
+  \brief Get the last element of the List
+  \return The last List element
+*/
+template<class T>
+List<T>* List<T>::get_last ()
+{
+  if (next == NULL) return this;
+  else return next->get_last();
+}
+
+/**
+  \brief Get the first element of the List
+  \return The first List element
+*/
+template<class T>
+List<T>* List<T>::get_first ()
+{
+  if (prev == NULL) return this;
+  else return prev->get_first();
+}
+
+/**
+  \brief Removes a certain element from the List
+  \param obj: A pointer to the object that should be removed
+  \param mode: A value of FINDMODE
+  \return 0 if the element was found and removed, -1 if the element was not found
+  
+  This searches the part of the List specified with mode for the object in question.
+  When the object is found it is deleted and the List element is removed from the chain.
+  If mode is LIST_FIND_FW all elements AFTER the base element are searched, if mode is
+  LIST_FIND_BW all elements BEFORE the base element are searched. Note that the object
+  contained within the List element is NOT deleted when bRef was set to true.
+*/
+template<class T>
+int List<T>::remove (T* obj, FINDMODE mode = LIST_FIND_FW)
+{
+  if (obj == NULL) return -1;
+  else
+  {
+    switch (mode)
+    {
+      case LIST_FIND_BW:
+        if (prev == NULL) return -1;
+        else
+        {
+          if( prev->get_object() == obj)
+          {
+            delete prev;
+          }
+          else
+          {
+            return prev->remove( obj, mode);
+          }
+        }
+        break;
+      case LIST_FIND_FW:
+        if (next == NULL) return -1;
+        else
+        {
+          if( next->get_object() == obj)
+          {
+            delete next;
+          }
+          else
+          {
+            return next->remove( obj, mode);
+          }
+        }
+        break;
+      default:
+        return -1;
+    }
+  }
+  return 0;
+}
+
+/**
+  \brief Set the next element of a List element
+  \param ptr: A pointer to the new next element
+    
+  Sets the next element of a List element... Better not touch this, it can really mess up a List.
+*/
+template<class T>
+void List<T>::set_next (List<T>* ptr)
+{
+  next = ptr;
+}
+
+/**
+  \brief Set the prev element of a List element
+  \param ptr: A pointer to the new previous element
+    
+  Sets the previous element of a List element... Better not touch this, it can really mess up a List.
+*/
+template<class T>
+void List<T>::set_prev (List<T>* ptr)
+{
+  prev = ptr;
+}
+
+/**
+  \brief Get the pointer to the object the element is containing
+  \return The contained object (will be NULL if called on the base element).
+*/
+template<class T>
+T* List<T>::get_object()
+{
+  return object;
+}
+
+
+
 #endif
+
Index: /orxonox/trunk/src/power_up.cc
===================================================================
--- /orxonox/trunk/src/power_up.cc	(revision 2077)
+++ /orxonox/trunk/src/power_up.cc	(revision 2077)
@@ -0,0 +1,32 @@
+
+
+/* 
+   orxonox - the future of 3D-vertical-scrollers
+
+   Copyright (C) 2004 orx
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   ### File Specific:
+   main-programmer: ...
+   co-programmer: ...
+*/
+
+
+#include "power_up.h"
+
+
+using namespace std;
+
+
+
+PowerUp::PowerUp () {}
+
+
+
+PowerUp::~PowerUp () {}
+
+
Index: /orxonox/trunk/src/power_up.h
===================================================================
--- /orxonox/trunk/src/power_up.h	(revision 2077)
+++ /orxonox/trunk/src/power_up.h	(revision 2077)
@@ -0,0 +1,21 @@
+/*! 
+    \file power_up.h
+    \brief A class representing a PowerUp in the world.
+*/ 
+
+#ifndef POWER_UP_H
+#define POWER_UP_H
+
+#include "data_tank.h"
+#include "ability.h"
+#include "world_entity.h"
+
+class PowerUp : Ability, WorldEntity { 
+
+ public:
+  PowerUp ();
+  ~PowerUp ();
+  
+};
+
+#endif
Index: /orxonox/trunk/src/world.cc
===================================================================
--- /orxonox/trunk/src/world.cc	(revision 2076)
+++ /orxonox/trunk/src/world.cc	(revision 2077)
@@ -28,4 +28,7 @@
 #include "data_tank.h"
 
+#include "list.h"
+#include "world_entity.h"
+
 #include "world.h"
 
@@ -37,16 +40,56 @@
    \brief Create a new World
    
-   This creates a new empty world!
+   This creates a new, empty world!
 */
 World::World () {
-  lastPlayer = null;
-  lastNPC = null;
-  lastEnv = null;
+  //lastPlayer = null;
+  //lastNPC = null;
+  //lastEnv = null;
   primitiveMove = 0;
   step = 0;
+
+  //List<int> *list = new List<int>();
+  npcList = new List<WorldEntity*>();
+  playerList = new List<WorldEntity*>();
+  envList = new List<WorldEntity*>();
 }
 
 
 World::~World () {}
+
+
+
+/** 
+   \brief Load a new World
+   
+   Load a new world. The old world (if any) will be unloaded and becomes unrecoverable. 
+*/
+void World::loadWorld() {}
+
+
+/** 
+   \brief Unloads a new World
+   
+   Unloads a world and frees the memory. You cant game until you have a new world loaded.
+*/
+void World::unloadWorld() {}
+
+
+/** 
+   \brief Pause the game
+   
+   Pauses the game until the pause is released. During this time nothing moves at all and nothing is calculated. Use it if you have to go out of the game to read some mails...
+*/
+void World::pauseWorld() {}
+
+
+/** 
+   \brief Save the game to file
+   \param filename: the filename where the savegame should be saved to
+   
+   Saves the state of the game to a file. The state is catched like in a multiplayer game over a synchronisable interface.
+*/
+void World::saveGameState(char* filename) {}
+
 
 
@@ -59,4 +102,7 @@
 bool World::addPlayer(Player* player) 
 {
+  WorldEntity *we;
+  playerList->add(we);
+  /*
   playerList* listMember = new playerList;
   listMember->player = player;
@@ -72,6 +118,6 @@
     }
   lastPlayer = listMember;
-}
-
+  */
+}
 
 /** 
@@ -79,10 +125,16 @@
    \param player A reference to the new npc object
    
-   Remove a new Player to the game.
+   Remove a new Player to the game. This kills the player objects.
 */
 bool World::removePlayer(Player* player) {
-  cout << "World::removeNPC not implemented yet" << endl;
-}
-
+  playerList->remove(player, LIST_FIND_BW);
+}
+
+/** 
+   \brief Returns the player-entity controlled by the local gamer
+   \return pointer to player object
+   
+   Remove a new Player to the game. This kills the player objects.
+*/
 Player* World::getLocalPlayer() 
 {
@@ -99,4 +151,6 @@
 bool World::addNPC(NPC* npc) 
 {
+  npcList->add(npc, LIST_ADD_NEXT);
+  /*
   npcList* listMember = new npcList;
   listMember->npc = npc;
@@ -112,4 +166,5 @@
     }
   lastNPC = listMember;
+  */
 }
 
@@ -117,10 +172,12 @@
 /** 
    \brief Remove Non-Player Character
-   \param player A reference to the new npc object
-   
-   Remove a new Non-Player-Character to the game.
-*/
-bool World::removeNPC(NPC* npc) {
-
+   \param player A reference to the npc object
+   
+   Remove a Non-Player-Character to the game.
+*/
+bool World::removeNPC(NPC* npc) 
+{
+  npcList->remove(npc, LIST_FIND_FW);
+  /*
   npcList* npcRef = lastNPC;
   npcList* lastRef = lastNPC;
@@ -128,5 +185,6 @@
     {
       if ( npcRef->npc == npc ) {
-	cout << "found" << endl;
+	cout <
+< "found" << endl;
 	if ( npcRef == lastRef ) {
 	  lastNPC = lastNPC->next;
@@ -148,4 +206,5 @@
     }
   cout << "npc left" << endl;
+  */
 }
 
@@ -160,4 +219,5 @@
 bool World::addEnv(Environment* env) 
 {
+  /*
   envList* listMember = new envList;
   listMember->env = env;
@@ -173,4 +233,16 @@
     }
   lastEnv = listMember;
+  */
+}
+
+/** 
+   \brief Remove an environmental object
+   \param player A reference to the env object
+   
+   Remove a environment from the game.
+*/
+bool World::removeEnv(Environment* env) 
+{
+  
 }
 
@@ -189,4 +261,7 @@
   gluLookAt(0.0, -14.0 + DataTank::yOffset, 15.0, 0.0, 0.0 + DataTank::yOffset, 0.0, 0.0, 1.0, 0.0);
   /* first draw all players */
+
+
+  /*
   playerList* tmpPlayer = lastPlayer;
   Player* player = tmpPlayer->player;
@@ -196,5 +271,7 @@
       tmpPlayer = tmpPlayer->next;
     }
+  */
   /* second draw all npcs */
+  /*
   npcList* tmpNPC = lastNPC;
   while( tmpNPC != null )
@@ -203,6 +280,8 @@
       tmpNPC = tmpNPC->next;
     }
+  */
 
   /* now draw the rest of the world: environement */
+  /*
   envList* tmpEnv = lastEnv;
   while( tmpEnv != null )
@@ -211,5 +290,6 @@
       tmpEnv = tmpEnv->next;
     }
-  
+  */
+
   /* draw the ground grid  */
   glColor3f(0.0, 1.0, 0.0); 
@@ -240,4 +320,5 @@
   DataTank::yOffset += step;
 
+  /*
   tmpPlayer = lastPlayer;
   while( tmpPlayer != null ) 
@@ -246,5 +327,5 @@
       tmpPlayer = tmpPlayer->next;
     }
-
+  */
 
 }
@@ -291,10 +372,12 @@
 void World::detectCollision() 
 {
+  /*
   //cout << "World::detectCollision" << endl;
   float xOff, yOff, zOff, radius;
   npcList* tmpNPC, *tmpRef;
-
+  */
   //cout << "World::detectCollsions" << endl;
   /* first: check if any player's shoots trigger a collision */
+  /*
   playerList* tmpPlayer = lastPlayer;
   Player* player = tmpPlayer->player;
@@ -318,4 +401,5 @@
 		  //cout << "COLLISION " << endl;
 		  int state = tmpNPC->npc->hit();
+  */
 		  /* state is a value that marks if the ship dies or not */
 		  /* if state == 0 the ship dies and we have to remove it */
@@ -327,5 +411,5 @@
 		    break;
 		  }
-		  */
+		  
 		}
 	      shoota = shoota->next;
@@ -338,9 +422,11 @@
       tmpPlayer = tmpPlayer->next;
       //cout << "changing play done" << endl;
-    }
-
+      
+    }
+		  */
   //cout << "World::detectCollisions middle" << endl;
 
   /* second: check if any player hits an enemy */
+/*
   tmpPlayer = lastPlayer;
   while( tmpPlayer != null ) 
@@ -365,5 +451,5 @@
   
   
-
+*/
   /* third: check if any enemy shoots a player */
 
@@ -380,6 +466,7 @@
 void World::testThaTest(void) 
 {
+/*
   cout << "World::testThaTest() called" << endl;
-  /* test addPlayer */
+
   cout << "addPlayer test..." << endl;
   playerList* pl = lastPlayer;
@@ -390,5 +477,5 @@
     }
 
-  /* test addNPC */
+
   cout << "addNPC test..." << endl;
   npcList* nl = lastNPC;
@@ -400,5 +487,5 @@
 
 
-  /* test addEnv */
+
   cout << "addEnv test..." << endl;
   envList* en = lastEnv;
@@ -408,5 +495,4 @@
       en = en->next;
     }
-
-  /* test drawWorld() */
-}
+*/
+}
Index: /orxonox/trunk/src/world.h
===================================================================
--- /orxonox/trunk/src/world.h	(revision 2076)
+++ /orxonox/trunk/src/world.h	(revision 2077)
@@ -1,2 +1,7 @@
+/**
+  Class representating the game-world
+  
+  It contains a list of players (if multiplayer game), a list of Non-Player-Characters (nps), a list of Environment Entities. All this things together are building the orxonox-world. This class also handels the story-line (track), the world start/stop, init/uninit abilities. It is the middle point of every orxonox world.
+*/
 
 #ifndef WORLD_H
@@ -6,6 +11,16 @@
 class NPC;
 class Environment;
+class WorldEntity;
+
+template<class T> class List;
 
 
+
+//! World Class
+/**
+  Class for World representation
+  
+  It contains a list of players (if multiplayer game), a list of Non-Player-Characters (nps), a list of Environment Entities. All this things together are building the orxonox-world. This class also handels the story-line (track), the world start/stop, init/uninit abilities. It is the middle point of every orxonox world.
+*/
 class World {
 
@@ -14,12 +29,13 @@
   ~World ();
 
-  float primitiveMove;
 
-  /* for easier use: map the first two player here */
-  Player *localPlayer;
-  Player *player1;
-  Player *player2;
 
-  /* a list of all players */
+  float primitiveMove; //!< deprecated, do not use
+
+  Player *localPlayer; //!< a pointer to the local player object
+  Player *player1;     //!< a pointer to the second player object
+  Player *player2;     //!< a pointer to the third player object 
+
+  /*
   struct playerList {
     playerList* next;
@@ -29,5 +45,4 @@
   playerList* lastPlayer;
 
-  /* a list of all non-player-characters */
   struct npcList {
     npcList* next;
@@ -37,5 +52,4 @@
   npcList* lastNPC;
 
-  /* a list of all environmental objects */
   struct envList {
     envList* next;
@@ -44,7 +58,12 @@
   };
   envList* lastEnv;
+  */
 
 
-
+  void loadWorld();
+  void unloadWorld();
+  void pauseWorld();
+  void saveGameState(char* filename);
+  
 
   bool addPlayer(Player* player);
@@ -54,5 +73,7 @@
   bool removeNPC(NPC* npc);
   bool addEnv(Environment* env);
+  bool removeEnv(Environment* env);
 
+  
   void drawWorld(void);
   void initEnvironement(void);
@@ -63,6 +84,10 @@
 
  private:
-  float surface[120][120];
-  float step;
+  float surface[120][120]; //!< deprecated: used to build a surface
+  float step; //!< this is the step
+
+  List<WorldEntity*> *playerList; //!< the list of players, usualy very short
+  List<WorldEntity*> *npcList;  //!< list of non player characters (npc)
+  List<WorldEntity*> *envList;  //!< list of environment objects
 
 
Index: /orxonox/trunk/src/world_entity.cc
===================================================================
--- /orxonox/trunk/src/world_entity.cc	(revision 2076)
+++ /orxonox/trunk/src/world_entity.cc	(revision 2077)
@@ -108,9 +108,9 @@
 /**
    \brief this method is called every tick
-   \param time: the time since start of the world
+   \param time: the time since the last frame was painted
 
    This function is called before every repaint of the world, to update every time dependent variable of the entity. If the entity moves, it has to calculate the new position every tick here in this function. Do not use this for animations.
 */
-void WorldEntity::tick(float time) 
+void WorldEntity::tick(float dt) 
 {}
 
@@ -121,7 +121,5 @@
 */
 void WorldEntity::paint() 
-{
-  cout << "WorldEntity::paint()" << endl;
-}
+{}
 
 /* virtual void WorldEntity::actionEvent(Event* event); */
Index: /orxonox/trunk/src/world_entity.h
===================================================================
--- /orxonox/trunk/src/world_entity.h	(revision 2076)
+++ /orxonox/trunk/src/world_entity.h	(revision 2077)
@@ -1,2 +1,10 @@
+/*! 
+    \file world_entity.h
+    \brief A base class for all objects in the world
+    
+    This is the base class of all objects in the game-world. If you want to have an object in the world, that can realy interact with other objects and that is also dispbayable etc. you have to extend this class and override the needed functions.
+*/ 
+
+
 
 #ifndef WORLD_ENTITY_H
@@ -8,4 +16,10 @@
 class Ability;
 
+//! WorldEntity
+/**
+  A base class for all objects in the world
+
+  This is the base class of all objects in the game-world. If you want to have an object in the world, that can realy interact with other objects and that is also dispbayable etc. you have to extend this class and override the needed functions.
+*/
 class WorldEntity {
 
@@ -28,5 +42,5 @@
   void removeAbility(Ability* ability);
 
-  virtual void tick(float time);
+  virtual void tick(float dt);
   virtual void paint();
   /* virtual void actionEvent(Event* event); */
@@ -43,11 +57,11 @@
 
  private:
-  Vector* position;
-  Vector* orientation;
+  Vector* position;    //!< position of the entity
+  Vector* orientation; //!< orientation of the entity
   /* List of abilities */ 
-  float health;
-  float speed;
+  float health; //!< health of the entity, if any
+  float speed; //!< speed of the entity if any
   /* entity can be in the air or at ground: */
-  int airGround;
+  int airGround; //!< is it air or bound to the ground (ground=0, air=1)
 
   
