Changeset 3681 in orxonox.OLD for orxonox/branches/textEngine/src/track_manager.cc

Timestamp:

Mar 30, 2005, 9:02:23 PM (20 years ago)

Author:

bensch

Message:

orxonox/branches/textEngine: merged trunk here.
merged with command:
svn merge ../trunk textEngine -r 3467:HEAD
no conflicts

File:

• orxonox/branches/textEngine/src/track_manager.cc (modified) (32 diffs)

orxonox/branches/textEngine/src/track_manager.cc

@@ -14 +14 @@
 */
 
+#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_TRACK_MANAGER
 
 #include "track_manager.h"
+
+#include "base_object.h"
+#include "p_node.h"
+#include "track_node.h"
+#include "stdincl.h"
+#include "list.h"
+
+
+
 #include <stdarg.h>
-#include "p_node.h"
 
 using namespace std;
@@ -32 +41 @@
   this->isJoined = false;
   this->mainJoin = false;
-  this->cond; //!< todo think!!
   this->ID = -1;
-  this->startingTime = 0; //!< \todo eventually set this to the max time of TrackManager.
-  this->duration = 1;
+  this->startingTime = 0;
+  this->duration = TMAN_DEFAULT_DURATION;
   this->endTime = 1;
   this->jumpTime = 0;
-  this->curveType = BEZIERCURVE;
+  this->width = TMAN_DEFAULT_WIDTH;
   this->nodeCount = 0;
   this->childCount = 0;
@@ -44 +52 @@
   this->curve = NULL;
   this->children = NULL;
+
+  this->history = NULL;
+
+  this->condFunc = &TrackElement::random;
 }
 
@@ -58 +70 @@
   if ((!this->isJoined &&this->childCount > 0) || (this->isJoined && this->mainJoin))
     {
-      for (int i=0; i < this->childCount; i++)
-        delete this->children[i];
+      tIterator<TrackElement>* iterator = this->children->getIterator();
+      TrackElement* enumElem = iterator->nextElement();
+      while (enumElem)
+        {
+          delete enumElem;
+          enumElem = iterator->nextElement();
+        }
+      delete iterator;
       delete this->children;
     }
@@ -78 +96 @@
   // search on.
   if (this->childCount > 0)
-    for (int i=0; i < this->childCount; i++)
-      {
-        TrackElement* tmpElem;
-        if ((tmpElem = this->children[i]->findByID(trackID)))
-          return tmpElem;
-      }
-  else return NULL;
-}
-
-
-
-
-
-/////////////////////////////////////
-///// TRACKMANAGER //////////////////
-/////////////////////////////////////
+    {
+      tIterator<TrackElement>* iterator = this->children->getIterator();
+      TrackElement* enumElem = iterator->nextElement();
+      TrackElement* tmpElem;
+      while (enumElem)
+        {
+          if ((tmpElem = enumElem->findByID(trackID)))
+            return tmpElem;
+          enumElem = iterator->nextElement();
+        }
+      delete iterator;
+    }
+  else 
+    return NULL;
+}
+
+
+/**
+   \brief checks if there are any BackLoops in the Track
+   \param trackElem the trackElement to check about
+   it simply does this by looking if the current trackElem is found again somewhere else in the Track
+*/
+bool TrackElement::backLoopCheck(TrackElement* trackElem)
+{
+  if (this->childCount == 0)
+    return true;
+  else
+    {
+      tIterator<TrackElement>* iterator = this->children->getIterator();
+      TrackElement* enumElem = iterator->nextElement();
+      while (enumElem)
+        {
+          if(!enumElem->backLoopCheck(trackElem))
+            return false;
+          enumElem = iterator->nextElement();
+        }
+      delete iterator;
+      
+      return true;
+    }
+}
+
+/**
+   \param childNumber which child to return
+   \returns the n-the children (starting at 0)
+*/
+TrackElement* TrackElement::getChild(int childCount)
+{
+  if (this->childCount == 0)
+    return NULL;
+  if (childCount > this->childCount)
+    childCount = this->childCount;
+  
+  TrackElement* enumElem = this->children->enumerate();
+  for (int i = 0; i < childCount; i++)
+    enumElem = this->children->nextElement();
+  return enumElem;
+}
+
+/**
+   \param name the Name to set.
+*/
+void TrackElement::setName(const char* name)
+{
+  //  delete the old name
+  if (this->name)
+    delete []this->name;
+  // if a name was given already.
+  if (name)
+    {
+      this->name = new char[strlen(name)+1];
+      strcpy(this->name, name);
+    }
+  else 
+    this->name = NULL;
+}
+
+/**
+   \returns The name of this TrackElement
+*/
+char* TrackElement::getName(void) const
+{
+  return this->name;
+}
+
+/**
+   \brief prints out debug information about this TrackElement
+*/
+void TrackElement::debug(void)
+{
+  PRINT(0)("--== TrackElement:%i ==--", this->ID);
+  if(this->getName())
+    PRINT(0)("Name: %s::", this->getName());
+  if(this->isFresh)
+    PRINT(0)("  -- has not jet eddited in any way --\n");
+  PRINT(0)("\n   TimeTable: startingTime=%f; endTime=%f; duration=%f; jumpTime=%f\n", this->startingTime, this->endTime, this->duration, this->jumpTime);
+  PRINT(0)("   consists of %d Points\n", this->nodeCount);
+  if (this->childCount == 0)
+    PRINT(0)("   has no child\n");
+  else if (this->childCount == 1)
+    PRINT(0)("   has 1 child: =%d=\n", this->getChild(0)->ID);
+  else if (this->childCount > 1)
+    {
+      PRINT(0)("   has %d children: ", this->childCount);
+      TrackElement* enumElem = this->children->enumerate();
+      while (enumElem)
+        {
+          PRINT(0)("=%d= ", enumElem->ID);
+          enumElem = this->children->nextElement();
+        }
+      PRINT(0)("\n");
+    }
+  
+  if(this->isHotPoint)
+    PRINT(0)("   is a special Point:\n");
+  if(this->isSavePoint)
+    PRINT(0)("    is a SavePoint\n");
+  if(this->isFork)
+    {
+      PRINT(0)("    is A Fork with with %d children.\n", this->childCount);
+    }
+  if(this->isJoined)
+    PRINT(0)("   is Joined at the End\n");
+  
+  if(!this->backLoopCheck(this)) /* this should not happen */
+    PRINT(2)(" THERE IS A BACKLOOP TO THIS ELEMENT\n");
+}
+
+/**
+   \brief CONDITION that chooses the first child for the decision (static)
+   \param nothing Nothing in this function
+   \returns the chosen child
+*/
+int TrackElement::lowest(void* nothing)
+{
+  return 0;
+}
+
+/**
+   \brief CONDITION that chooses the last child for the decision (static)
+   \param nothing Nothing in this function
+   \returns the chosen child
+*/
+int TrackElement::highest(void* nothing)
+{ 
+  return this->childCount-1;
+}
+
+/**
+   \brief CONDITION that chooses a random child for the decision (static)
+   \param nothing Nothing in this function
+   \returns the chosen child
+*/
+int TrackElement::random(void* nothing)
+{
+  int i = (int)floor ((float)rand()/(float)RAND_MAX * (float)this->childCount);
+  if (i >= this->childCount)
+    return this->childCount-1;
+  else 
+    return i;
+}
+
+/**
+   \brief CONDITION that chooses child 0, if the node(probably Player)
+   is left of its parent (z<0)) and 1/right otherwise.
+   \param node The node to act upon.
+   \returns the chosen child
+*/
+int TrackElement::leftRight(void* node)
+{
+  PNode* tmpNode = (PNode*)node;
+
+  if (tmpNode->getRelCoor()->z < 0)
+    return 0;
+  else 
+    return 1;
+}
+
+
+/**
+   \brief CONDITION that chooses the child, that has the nearest distance to the node (probably player).
+   \param node The node to act upon.
+   \returns the chosen child
+
+   This is rather dangerous, because one must carefully set the points on the curve.
+   The best Way is to set the nodes as wide away of each other as possible,
+   but take into consideration, that if the nodes are to far from a center node, the center will be chosen.
+   (play with this!!).
+*/
+int TrackElement::nearest(void* node)
+{
+  PNode* tmpNode = (PNode*)node;
+
+  Vector nodeRelCoord = *tmpNode->getRelCoor();
+  float minDist = 100000000;
+  int childNumber = 0;
+  int i = 0;
+
+  TrackElement* enumElem = this->children->enumerate();
+  while (enumElem)
+    {
+      float dist = (nodeRelCoord - enumElem->curve->getNode(4)).len();
+      if (dist < minDist)
+        {
+          minDist = dist;
+          childNumber = i;
+        }
+      i++;
+      enumElem = this->children->nextElement();
+    }
+
+  PRINTF(4)("PathDecision with nearest algorithm: %d\n", childNumber);
+  return childNumber;
+}
+
+
+////////////////////////
+///// TRACKMANAGER /////
+////////////////////////
 /**
    \brief standard constructor
@@ -100 +321 @@
 TrackManager::TrackManager(void)
 {
-  this->setClassName ("TrackManager");
+  this->setClassName("TrackManager");
+  
+  TrackManager::singletonRef = this;
 
   PRINTF(3)("Initializing the TrackManager\n");
@@ -109 +332 @@
   this->maxTime = 0;
   this->trackElemCount = 1;
-  this->bindSlave = NULL;
+  this->setBindSlave(this->trackNode = new TrackNode());
 }
 
@@ -115 +338 @@
 /**
    \brief standard destructor
-
 */
 TrackManager::~TrackManager(void)
@@ -121 +343 @@
   PRINTF(3)("Destruct TrackManager\n");
 
-  PRINTF(3)("Deleting all the TrackElements\n");
+  PRINTF(4)("Deleting all the TrackElements\n");
   delete this->firstTrackElem;
 
   // we do not have a TrackManager anymore
-  singletonRef = NULL;
-}
-
+  TrackManager::singletonRef = NULL;
+}
+
+//! Singleton Reference to TrackManager
 TrackManager* TrackManager::singletonRef = NULL;
 
@@ -137 +360 @@
 TrackManager* TrackManager::getInstance(void) 
 {
-  if (singletonRef)
-    return singletonRef;
-  else
-    return singletonRef = new TrackManager();
+  if (!TrackManager::singletonRef)
+    TrackManager::singletonRef = new TrackManager();
+  return TrackManager::singletonRef;
 }
 
@@ -151 +373 @@
   this->currentTrackElem->childCount = childCount;
   this->currentTrackElem->mainJoin = true;
-  this->currentTrackElem->children = new TrackElement*[childCount];
-  for (int i=0; i<childCount; i++)
-    {
-      this->currentTrackElem->children[i] = new TrackElement();
-      this->currentTrackElem->children[i]->ID = ++trackElemCount;
-      this->currentTrackElem->children[i]->startingTime = this->currentTrackElem->endTime + this->currentTrackElem->jumpTime;
-      this->addPoint(this->currentTrackElem->curve->getNode(this->currentTrackElem->curve->getNodeCount()), this->currentTrackElem->children[i]);
-    }
+  this->currentTrackElem->children =  new tList<TrackElement>();
+  for (int i = 0; i < childCount; i++)
+    {
+      TrackElement* newElem = new TrackElement();
+      this->currentTrackElem->children->add(newElem);
+      newElem->ID = ++trackElemCount;
+      newElem->startingTime = this->currentTrackElem->endTime + this->currentTrackElem->jumpTime;
+      this->addPoint(this->currentTrackElem->curve->getNode(this->currentTrackElem->curve->getNodeCount()), this->currentTrackElem->getChild(i));
+    }
+  if (childCount == 1)
+    this->currentTrackElem->getChild(0)->setName(this->currentTrackElem->getName());
 }
 
@@ -183 +408 @@
     this->currentTrackElem = tmpElem;
   else
-    printf("TrackElement not Found, leaving unchanged\n");
-  printf("now Working on %d\n", this->currentTrackElem->ID);
+    PRINTF(2)("TrackElement not Found, leaving unchanged\n");
+  PRINTF(4)("now Working on %d\n", this->currentTrackElem->ID);
 
 }
@@ -190 +415 @@
 /**
    \brief Sets the Type of the Curve
-   \brief curveType The Type to set
+   \param curveType The Type to set
+   \param trackElem the TrackElement that should get a new Curve.
 */
 void TrackManager::setCurveType(CurveType curveType, TrackElement* trackElem)
@@ -199 +425 @@
       return;
     }
-  trackElem->curveType = curveType;
+  this->curveType = curveType;
   switch (curveType)
     {
@@ -205 +431 @@
       trackElem->curve = new BezierCurve();
       break;
-    case UPOINTCURVE:
-      trackElem->curve = new UPointCurve();
-      break;
+
     }
 }
@@ -240 +464 @@
   if (trackElem->isFresh)
     {
-      this->setCurveType(BEZIERCURVE, trackElem);
+      this->setCurveType(TMAN_DEFAULT_CURVETYPE, trackElem);
       trackElem->isFresh = false;
     }
@@ -254 +478 @@
 int TrackManager::addHotPoint(Vector newPoint)
 {
-  printf("setting up a HotPoint\n");
+  PRINTF(4)("setting up a HotPoint\n");
   if (this->currentTrackElem->isFresh)
     {
@@ -265 +489 @@
   this->currentTrackElem->nodeCount++;
   this->initChildren(1);
-  this->currentTrackElem = this->currentTrackElem->children[0];
+  this->currentTrackElem = this->currentTrackElem->getChild(0);
 }
 
@@ -277 +501 @@
 int TrackManager::setSavePoint(void)
 {
-  printf("setting up a SavePoint.\n");
+  PRINTF(4)("setting up a SavePoint.\n");
   if (this->currentTrackElem->isFork || this->currentTrackElem->isSavePoint)
-    return this->currentTrackElem->children[1]->ID;
+    {
+      PRINTF(2)("%d is already finished \n", currentTrackElem->ID);
+      return this->currentTrackElem->getChild(0)->ID;
+    }
   this->currentTrackElem->isSavePoint = true;
   this->currentTrackElem->isHotPoint = true;
 
   this->initChildren(1);
-  this->currentTrackElem = this->currentTrackElem->children[0];
+  this->currentTrackElem = this->currentTrackElem->getChild(0);
 }
 
@@ -319 +546 @@
 void TrackManager::forkV(unsigned int count, int* trackIDs)
 {
-  printf("Forking with %d children\n", count);
+  PRINTF(4)("Forking with %d children\n", count);
   if (this->currentTrackElem->isSavePoint)
     return;
@@ -331 +558 @@
 /**
    \brief decides under what condition a certain Path will be chosen.
+   \param cond the CONDITION of the decision
+   \param subject the Subject that will be decided upon with CONDITION cond.
+*/
+void TrackManager::condition(CONDITION cond, void* subject)
+{
+  this->condition(this->currentTrackElem->ID, cond, subject);
+}
+/**
+   \brief decides under what condition a certain Path will be chosen.
    \param groupID the ID on which to choose the preceding move
-   \param cond \todo think about this
-*/
-void TrackManager::condition(unsigned int groupID, PathCondition cond)
-{
-  
-}
+   \param cond the CONDITION of the decision
+   \param subject the Subject that will be decided upon with CONDITION cond.
+*/
+void TrackManager::condition(unsigned int groupID, CONDITION cond, void* subject)
+{
+  TrackElement* tmpElem = this->findTrackElementByID(groupID);
+  if (!tmpElem->isFork)
+    {
+      PRINTF(2)("%d is not a Fork, and no condition can be set in this case\n", tmpElem->ID);
+      return;
+    }
+  else
+    {
+      switch (cond)
+        {
+        case LOWEST:
+          tmpElem->condFunc = &TrackElement::lowest;
+          break;
+        case HIGHEST:
+          tmpElem->condFunc = &TrackElement::highest;
+          break;
+        case RANDOM: 
+          tmpElem->condFunc = &TrackElement::random;
+          break;
+        case LEFTRIGHT:
+          tmpElem->condFunc = &TrackElement::leftRight;
+          break;
+        case NEAREST:
+          tmpElem->condFunc = &TrackElement::nearest;
+          break;
+        case ENEMYKILLED:
+          break;
+        }
+      tmpElem->subject=subject;
+    }
+}
+
 
 /**
@@ -369 +636 @@
 void TrackManager::joinV(unsigned int count, int* trackIDs)
 {
-  printf("Joining %d tracks and merging to Track %d\n", count, trackIDs[0]);
+  PRINTF(3)("Joining %d tracks and merging to Track %d\n", count, trackIDs[0]);
+
+  // checking if there is a back-loop-connection and ERROR if it is.
+  TrackElement* tmpTrackElem = this->findTrackElementByID(trackIDs[0]);
+  if (!tmpTrackElem->backLoopCheck(tmpTrackElem))
+    PRINTF(2)("Backloop connection detected at joining trackElements\n");
 
   // chanching work-on to temporary value. going back at the end.
@@ -419 +691 @@
     }
   if(firstJoint->childCount > 0)
-    for(int i = 0; i < firstJoint->childCount; i++)
-      {
-        printf("Setting startingTime of %d to %f.\n", firstJoint->children[i]->ID, tmpLatestTime);
-        firstJoint->children[i]->startingTime = tmpLatestTime;
-        firstJoint->children[i]->endTime = tmpLatestTime+firstJoint->children[i]->duration;
-      } 
-
+    {
+      TrackElement* enumElem = firstJoint->children->enumerate();
+      while (enumElem)
+        {
+          PRINTF(4)("Setting startingTime of %d to %f.\n", enumElem->ID, tmpLatestTime);
+          enumElem->startingTime = tmpLatestTime;
+          enumElem->endTime = tmpLatestTime + enumElem->duration;
+          
+          enumElem = firstJoint->children->nextElement();
+        }
+    }
   // returning to the TrackElement we were working on.
   this->workOn(tmpCurrentWorkingID);
@@ -440 +716 @@
     {
       TrackElement* tmpElem = findTrackElementByID(i);
-      if (tmpElem->childCount>0 && tmpElem->mainJoin)
+      if (tmpElem->childCount > 0 && tmpElem->mainJoin)
         {
-          for (int j = 0; j < tmpElem->childCount; j++)
+
+          TrackElement* enumElem = tmpElem->children->enumerate();
+          while (enumElem)
             {
               
               // c1-continuity
-              tmpElem->children[j]->curve->addNode(tmpElem->children[j]->curve->getNode(0) +
-                                                   ((tmpElem->children[j]->curve->getNode(0) - 
+              enumElem->curve->addNode(enumElem->curve->getNode(0) +
+                                                   ((enumElem->curve->getNode(0) - 
                                                     tmpElem->curve->getNode(tmpElem->curve->getNodeCount()-1))
                                                     ),2);
-              tmpElem->children[j]->nodeCount++;
+              enumElem->nodeCount++;
               // c2-continuity
-              tmpElem->children[j]->curve->addNode((tmpElem->curve->getNode(tmpElem->curve->getNodeCount())-
+              enumElem->curve->addNode((tmpElem->curve->getNode(tmpElem->curve->getNodeCount())-
                                                     tmpElem->curve->getNode(tmpElem->curve->getNodeCount()-1)) * 4 +
                                                    tmpElem->curve->getNode(tmpElem->curve->getNodeCount()-2), 3);
-              tmpElem->children[j]->nodeCount++;                                                    
-              printf("accelerations: %d-in: count: %d, %f, %f, %f\n                  %d-out: count: %d %f, %f, %f\n",
+              enumElem->nodeCount++;                                                
+              PRINTF(5)("accelerations: %d-in: count: %d, %f, %f, %f\n                  %d-out: count: %d %f, %f, %f\n",
                      tmpElem->ID, tmpElem->nodeCount,
                      tmpElem->curve->calcAcc(0.999).x, tmpElem->curve->calcAcc(0.999).y, tmpElem->curve->calcAcc(0.999).z,
-                     tmpElem->children[j]->ID, tmpElem->children[j]->nodeCount,
-                     tmpElem->children[j]->curve->calcAcc(0).x, tmpElem->children[j]->curve->calcAcc(0).y, tmpElem->children[j]->curve->calcAcc(0).z);
+                     enumElem->ID, enumElem->nodeCount,
+                     enumElem->curve->calcAcc(0).x, enumElem->curve->calcAcc(0).y, enumElem->curve->calcAcc(0).z);
+              
+              enumElem = tmpElem->children->nextElement();
             }
         }
     }
+  for (int i = 1; i <=trackElemCount;i++)
+    if (this->findTrackElementByID(i)->endTime > this->maxTime)
+      this->maxTime = findTrackElementByID(i)->endTime; // very bad implemented :/
 }
 
@@ -475 +758 @@
 Vector TrackManager::calcPos() const
 {
-  //  PRINTF(0)("TrackElement:%d, localTime: %f\n",this->currentTrackElem->ID, this->localTime);
   return this->currentTrackElem->curve->calcPos((this->localTime-this->currentTrackElem->startingTime)/this->currentTrackElem->duration);
 }
@@ -489 +771 @@
 
 /**
+   \returns the current Width of the track
+*/
+float TrackManager::getWidth(void) const
+{
+  return this->currentTrackElem->width;
+}
+
+/**
    \brief Advances the local-time of the Track around dt
    \param dt The time about which to advance.
@@ -497 +787 @@
 {
   dt /= 1000;
-  printf("CurrentTrackID: %d, LocalTime is: %f, timestep is: %f\n", this->currentTrackElem->ID, this->localTime, dt);
+  PRINTF(4)("CurrentTrackID: %d, LocalTime is: %f, timestep is: %f\n", this->currentTrackElem->ID, this->localTime, dt);
   if (this->localTime <= this->firstTrackElem->duration)
     this->jumpTo(this->localTime);
-  this->localTime += dt;
+  if (this->localTime <= this->maxTime)
+    this->localTime += dt;
   if (this->localTime > this->currentTrackElem->endTime
       && this->currentTrackElem->children)
     {
-      if (this->currentTrackElem->jumpTime > 0) 
+      if (this->currentTrackElem->jumpTime != 0.0)
         this->jumpTo(this->localTime + this->currentTrackElem->jumpTime);
-      this->currentTrackElem = this->currentTrackElem->children[0];
+      // jump to the next TrackElement and also set the history of the new Element to the old one.
+      TrackElement* tmpHistoryElem = this->currentTrackElem;
+      this->currentTrackElem = this->currentTrackElem->getChild(this->choosePath(this->currentTrackElem));
+      this->currentTrackElem->history = tmpHistoryElem;
     }
   if (this->bindSlave)
@@ -512 +806 @@
       Vector tmp = this->calcPos();
       Quaternion quat = Quaternion(this->calcDir(), Vector(this->currentTrackElem->curve->calcAcc((localTime-this->currentTrackElem->startingTime)/this->currentTrackElem->duration).x,1,this->currentTrackElem->curve->calcAcc((localTime-this->currentTrackElem->startingTime)/this->currentTrackElem->duration).z)); 
+
+      Vector v(0.0, 1.0, 0.0);
+      Quaternion q(-PI/2, v);
+      quat = quat * q;
+
       this->bindSlave->setAbsCoor(&tmp);
       this->bindSlave->setAbsDir(&quat);
@@ -533 +832 @@
 /**
    \brief a Function that decides which Path we should follow.
-   \param graphID The Path to choose.
+   \param trackElem The Path to choose.
    
 */
-void TrackManager::choosePath(int graphID)
-{
-
+int TrackManager::choosePath(TrackElement* trackElem)
+{
+  return (trackElem->*(trackElem->condFunc))(trackElem->subject);
 }
 
@@ -547 +846 @@
 void TrackManager::setBindSlave(PNode* bindSlave)
 {
-  if (!this->bindSlave)
-    this->bindSlave = bindSlave;
-}
-
+  this->bindSlave = bindSlave;
+}
+
+/**
+   \returns the main TrackNode
+*/
+PNode* TrackManager::getTrackNode(void)
+{
+  return this->trackNode;
+}
 
 // DEBUG //
@@ -585 +890 @@
 void TrackManager::debug(unsigned int level) const
 {
-  printf("::CLASS TRACKMANAGER::debug information::\n");
-  //  printf("Status is: %
-  printf(" Consists of %d elements\n", this->trackElemCount);
-  printf(" localTime is: %f\n", this->localTime);
+  PRINT(0)("=========================================\n");
+  PRINT(0)("= CLASS TRACKMANAGER::debug information =\n");
+  PRINT(0)("=========================================\n");
+  //  PRINT(0)("Status is: %
+  PRINT(0)(" Consists of %d elements\n", this->trackElemCount);
+  PRINT(0)(" localTime is: %f\n", this->localTime);
   if (level >= 2)
     {
@@ -594 +901 @@
         {
           TrackElement* tmpElem = this->findTrackElementByID(i);
-          printf("  ::TrackElement:%i::", tmpElem->ID);
-          if(tmpElem->name)
-            printf("name:%s::", tmpElem->name);
-          if(tmpElem->isFresh)
-            printf("   has not jet eddited in any way\n");
-          printf("\n   TimeTable: startingTime=%f; endTime=%f; duration=%f; jumpTime=%f\n", tmpElem->startingTime, tmpElem->endTime, tmpElem->duration, tmpElem->jumpTime);
-          printf("   consists of %d Points\n", tmpElem->nodeCount);
-          if (tmpElem->childCount == 0)
-            printf("   has no child\n");            
-          else if (tmpElem->childCount == 1)
-            printf("   has 1 child: ==%d==\n", tmpElem->children[0]->ID);
-          else if (tmpElem->childCount > 1)
-            {
-              printf("   has %d children: ", tmpElem->childCount);
-              for(int i = 0; i < tmpElem->childCount; i++)
-                printf("=%d= ", tmpElem->children[i]->ID);
-              printf("\n");
-            }
-
-          if(tmpElem->isHotPoint)
-            printf("   is a special Point:\n");
-          if(tmpElem->isSavePoint)
-            printf("    is a SavePoint\n");
-          if(tmpElem->isFork)
-            {
-              printf("    is A Fork with with %d children.\n", tmpElem->childCount);
-            }
-          if(tmpElem->isJoined)
-            printf("   is Joined at the End\n");
+          tmpElem->debug();
         }
     }
-}
+  PRINT(0)("-----------------------------------------\n");
+}