Index: trunk/src/world_entities/spawning_point.cc
===================================================================
--- trunk/src/world_entities/spawning_point.cc	(revision 7356)
+++ trunk/src/world_entities/spawning_point.cc	(revision 7357)
@@ -24,11 +24,12 @@
 
 /**
- *  standard constructor
+ *  constructor
  */
-SpawningPoint::SpawningPoint (World* world, const Vector& absCoordinate)
+SpawningPoint::SpawningPoint (ClassID classID, const Vector& position)
 {
-  this->world = world;
-  this->frequency = 0.5f;
-  this->seed = 0.0f;
+  this->setAbsCoor(position);
+  this->classID = classID;
+  this->mode = SPT_ALL_AT_ONCE;
+  this->delay = 0;
 
   this->init();
@@ -37,13 +38,12 @@
 
 /**
- *  constructor
+ *  standard constructor
  */
-SpawningPoint::SpawningPoint (const Vector& position, float frequency,
-                              float seed, ClassID classID, World* world)
+SpawningPoint::SpawningPoint (const Vector& position, ClassID classID, SpawningPointMode mode, float delay)
 {
-  this->frequency = frequency;
-  this->seed = seed;
+  this->setAbsCoor(position);
   this->classID = classID;
-  this->world = world;
+  this->mode = mode;
+  this->delay = delay;
 
   this->init();
@@ -51,7 +51,8 @@
 
 
+
 void SpawningPoint::init()
 {
-  this->countDown = 0.0f;
+  this->setClassID(CL_SPAWNING_POINT, "SpawningPoint");
 }
 
@@ -74,13 +75,11 @@
 
   /* now load the frequency */
-  LoadParam(root, "frequency", this, SpawningPoint, setSpawningFrequency)
-  .describe("sets the frequency of the spawning point")
-  .defaultValues(1.0f);
+  LoadParam(root, "delay", this, SpawningPoint, setSpawningDelay)
+      .describe("sets the delay of the spawning point");
 
 
   /* now load the seed */
-  LoadParam(root, "randomseed", this, SpawningPoint, setPositionSeed)
-      .describe("sets the random position seed (variance in the spawning location around the position)")
-      .defaultValues(0.0f);
+//   LoadParam(root, "entity", this, SpawningPoint, setSpawningEntity)
+//       .describe("sets the spawning entity");
 
   /* now load the seed */
@@ -96,7 +95,8 @@
 void SpawningPoint::spawn()
 {
-  PRINTF(5)("Spangingpoint creates a new Entity (id: %i, frequency: %f, seed: %f)\n", this->classID,
-            this->frequency, this->seed);
-  BaseObject* spawningEntity = Factory::fabricate(this->classID);
+  PRINTF(5)("Spangingpoint creates a new Entity (id: %i, delay: %f, mode: %f)\n", this->classID,
+            this->delay, this->mode);
+
+  //BaseObject* spawningEntity = Factory::fabricate(this->classID);
 
 //   if( likely(this->world != NULL))
@@ -113,9 +113,9 @@
 void SpawningPoint::tick(float dt)
 {
-  this->countDown += dt;
-  if( this->countDown > this->frequency)
+  this->localTimer += dt;
+  if( this->localTimer > this->delay)
   {
     this->spawn();
-    this->countDown = 0.0f;
+    this->localTimer = 0.0f;
   }
 }
Index: trunk/src/world_entities/spawning_point.h
===================================================================
--- trunk/src/world_entities/spawning_point.h	(revision 7356)
+++ trunk/src/world_entities/spawning_point.h	(revision 7357)
@@ -13,10 +13,28 @@
 class TiXmlElement;
 
-//! The spawning point for world entities
+
+//!< used to indicate what type of objects are spawned by this spawning point
+typedef enum SpawningPointMode
+{
+  SPT_ALL_AT_ONCE = 0,                               //!< at this spawning points there will be players spawned (typicaly in MP games)
+  SPT_ONE_AFTER_OTHER,                               //!< at this spawning points there will be NPS spawnded
+
+  SPT_NUMBER
+};
+
+
+/**
+ * The spawning point for WorldEntities (and only WorldEntities)
+ *
+ * There are commonly two different spawning modes:
+ *
+ *  1) Just spawn whatever is in the queue with a given frequency (if delay = 0 => immediate spawn)
+ *  2) Spawn everything in the queue together with the given frequency
+ */
 class SpawningPoint : public WorldEntity {
 
   public:
-    SpawningPoint (World* world, const Vector& absCoordinate = Vector(0.0, 0.0, 0.0));
-    SpawningPoint (const Vector& position, float frequency, float seed, ClassID classID, World* world);
+    SpawningPoint (ClassID classID, const Vector& position = Vector(0.0, 0.0, 0.0));
+    SpawningPoint (const Vector& position, ClassID classID, SpawningPointMode type, float delay);
     virtual ~SpawningPoint ();
     void init();
@@ -27,20 +45,31 @@
     void SpawningPoint::setSpawningEntity(ClassID classID) { this->classID = classID; }
     /** sets the frequency with which the point is going to spawn entities (1/sec) @param frequency: the frequency */
-    void SpawningPoint::setSpawningFrequency(float frequency) { this->frequency = frequency; }
-    /**  sets the seed of the position vector @param seed: the random seed around the given vector */
-    void SpawningPoint::setPositionSeed(float seed) { this->seed = seed; }
+    void SpawningPoint::setSpawningDelay(float delay) { this->delay = delay; }
+    /** sets the spawning point mode @param mode: the mode */
+    void SpawningPoint::setSpawningMode(int mode) { this->mode = (SpawningPointMode)mode; }
 
-    void spawn();
+
+    /** activates the spawning point */
+    void activate() { this->bSpawning = true; }
+    /** deactivates the spawning point */
+    void deactivate() { this->bSpawning = false; }
+
 
     virtual void tick(float dt);
     virtual void draw();
 
+
   private:
-    float                frequency;                      //!< the frequency for entity spawning
-    float                countDown;                      //!< the timer that counts down until the next spawn
-    float                seed;                           //!< the random seed of the position
-    ClassID              classID;                        //!< the classid of the entity to spawn
-    World*               world;                          //!< reference to the world it belongs to (or in the future: the object manager)
+    void spawn();
 
+
+  private:
+    float                     delay;                          //!< the timer that counts down until the next spawn
+    float                     localTimer;                     //!< the local timer
+    float                     seed;                           //!< the random seed of the position
+    ClassID                   classID;                        //!< the classid of the entity to spawn
+    SpawningPointMode         mode;                           //!< the mode of the spawning point
+    std::list<WorldEntity*>   queue;                          //!< queue of waiting WorldEntities to be spawned
+    bool                      bSpawning;                      //!< flag to indicate if this spawning point is active or not
 };
 
