source: orxonox.OLD/orxonox/branches/parenting/src/track_manager.h @ 3330

/*! 
    \file track_manager.h
    \brief manages all tracks defined in the world and the path the player takes

    it is a container for all tracks and all track-nodes. it manages the movement of
    the track helper-parent (that drives the player). it is responsable for calculating
    smooth curves etc.
*/


#ifndef _TRACK_MANAGER_H
#define _TRACK_MANAGER_H

#include "stdincl.h"


//! The TrackManager handles the flow of the Players through the game.
/**
   \todo write the methodes

   <b>The TrackManager works as followed:</b> \n
     \n
   <b>1. Initialize it, by setting up the Graph. You can do this by using the following Commands.</b>
    \li workOn(): changes the ID that will be altered through the changes.
    \li setType: lets you set the CurveType of the Curve we are Working on. (default is BezierCurve, set this as early as possible, for this uses resources).
    \li setLength(): sets the length of the current path in seconds.
    \li addPoint(): adds a point to the Curve.
    \li addHotPoint(): adds save/splitpoint.\n
    \li fork(): adds some interessting non-linear movments through the level (fork will force addHotPoint if not done then).
    \li condition(): decides under what condition a certain Path will be chosen.
    \li join(): joins some tracks together again. Join will set the localTime to the longest time a Path has to get to this Point)
    \li setSavePoint(): Sets a HotPoint into a savePoint. A Savepoint can be used as a rollbackpoint if a Player gets shot.


    look out: <b>SAVEPOINTS CAN NOT BE FORKS</b> (but joins), because the condition is really hard to guess if you do not give some impuls. \n
\n
   <b> 2. Runtime knows the following: </b>
    \li calcPos(): returns the current position on the track
    \li calcDir(): returns the current Direction the track is flying on.
    \li tick(): makes a Step on the Path. increases localTime by dt.
    \li choosePath(): a Function that decides which Path we should follow.
   
   TrackManager can be handled as a StateMachine.
*/
class TrackManager : public BaseObject {
 private:
  //! condition for choosing a certain Path. \todo implement a useful way.
  struct PathCondition
  {
    
  };
  
  //! A Graph, that holds the curve-structure of a Level.
  /**
     A CurveGraph is used, to Define the structure of the Track itself.
     It is a graph and not a tree, because paths can fork and join again.
  */
  struct TrackElement
  {
    bool isSavePoint;          //!< If the first node is a savePoint
    bool isFork;               //!< If the first node is a Fork
    bool isJoined;             //!< If the End of the Curve is joined.
    PathCondition cond;        //!< The Split Condition;
    int ID;                    //!< The ID of this TrackElement
    float length;              //!< The time usedto cross this TrackElement (curve).
    CurveType curveType;       //!< The CurveType this will have.
    int nodeCount;             //!< The count of points this TrackElement has.
    Curve* curve;              //!< The Curve of this TrackElement
    TrackElement** children;   //!< A TrackElement can have a Tree of following TrackElements.
  };


  TrackElement* firstGraph;    //!< The first Graph-element we are on.
  TrackElement* currentGraph;  //!< The Graph-element we are working on.
  float localTime;             //!< The time that has been passed since the traveling the Track.
  int trackElementCount;       //!< The count of TrackElements that exist.
  
  TrackElement findTrackElementByID(int trackID);

 public:
  TrackManager ();
  ~TrackManager ();

  // Methods to change the Path (initialisation)
  void workOn(int trackID);
  void setType(CurveType curveType);
  void setLength(float time);
  void addPoint(Vector newPoint);
  void addHotPoint(Vector newPoint);
  void setSavePoint(void);
  void fork(int count, ...);
  void forkV(int count, int* trackIDs);
  void condition(int groupID, PathCondition cond); //!< \todo really do this!!
  void join(int count, ...);
  void joinV(int count, int* trackIDs);

  // Methods to calculate the position on the Path (runtime)
  Vector calcPos();
  Vector calcDir();
  void tick(float dt);
  void choosePath(int graphID);

};

#endif /* _TRACK_MANAGER_H */