Changeset 3330 in orxonox.OLD for orxonox

Timestamp:

Jan 4, 2005, 5:44:21 AM (20 years ago)

Author:

bensch

Message:

orxonox/branches/parenting: written the Headers for the class TrackManager: this will be a lot of work.

Location:

orxonox/branches/parenting/src

Files:

• curve.cc (modified) (1 diff)
• curve.h (modified) (1 diff)
• track_manager.cc (modified) (1 diff)
• track_manager.h (modified) (2 diffs)

orxonox/branches/parenting/src/curve.cc

@@ -27 +27 @@
 #include <math.h>
 #include <stdio.h>
-
 
 /**

orxonox/branches/parenting/src/curve.h

@@ -11 +11 @@
 
 #include "vector.h"
+
+//! An Enumerator that defines what sort of Curves are availible
+enum CurveType {BEZIER, UPOINT};
 
 

orxonox/branches/parenting/src/track_manager.cc

@@ -39 +39 @@
    \todo this deconstructor is not jet implemented - do it
 */
-TrackManager::~TrackManager () {}
-
+TrackManager::~TrackManager () 
+{
+
+}
+
+/**
+   \brief Searches for a given trackID.
+   \param trackID the trackID to search for.
+   \returns The TrackElement #trackID if found, NULL otherways.
+*/
+TrackElement TrackManager::findTrackElementByID(int trackID)
+{
+
+}
+
+// INITIALIZE //
+
+/**
+   \brief Sets the trackID we are working on.
+   \param trackID the trackID we are working on
+*/
+void TrackManager::workOn(int trackID)
+{
+
+}
+
+/**
+   \brief Sets the Type of the Curve
+   \brief curveType The Type to set
+*/
+void TrackManager::setType(CurveType curveType)
+{
+
+}
+
+/**
+   \brief Sets the length of the current path in seconds.
+   \param time The length in seconds.
+*/
+
+void TrackManager::setLength(float time)
+{
+
+}
+
+/**
+   \brief adds a point to the current TrackElement
+   \param newPoint The point to add.
+*/
+void TrackManager::addPoint(Vector newPoint)
+{
+
+}
+
+/**
+   \brief adds save/splitpoint.
+   \param newPoint The point to add.
+*/
+void TrackManager::addHotPoint(Vector newPoint)
+{
+
+}
+
+/**
+   \brief Sets the last HotPoint into a savePoint.
+   
+   If no HotPoint was defined the last added Point will be rendered into a savePoint. \n
+   If the HotPoint was defined as a fork the Point will \b not be set into a savePoint.
+*/
+void TrackManager::setSavePoint(void)
+{
+  
+}
+
+/**
+   \brief adds some interessting non-linear movments through the level.
+   \param count The Count of childrens the current HotPoint will have.
+
+   If no HotPoint was defined the last added Point will be rendered into a fork. \n
+   If the HotPoint was defined as a savePoint the Point will \b not be set into a fork.
+*/
+void TrackManager::fork(int count, ...)
+{
+
+}
+
+/**
+   \brief adds some interessting non-linear movments through the level.
+   \param count The Count of childrens the current HotPoint will have.
+   \param trackIDs A Pointer to an Array of ints which will hold the trackID's (the user will have to reserve space for this).
+
+   \see void TrackManager::fork(int count, ...)
+*/
+void TrackManager::forkV(int count, int* trackIDs)
+{
+
+}
+
+/**
+   \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(int groupID, PathCondition cond)
+{
+
+}
+
+/**
+   \brief joins some tracks together again. 
+   \param count The count of Paths to join.
+
+   Join will set the localTime to the longest time a Path has to get to this Point. \n
+   Join will join all curves to the first curve.
+*/
+void TrackManager::join(int count, ...)
+{
+
+}
+
+/**
+   \brief joins some tracks together again. 
+   \param count The count of Paths to join.
+   \param trackIDs an Array with the trackID's to join
+
+   \see void TrackManager::join(int count, ...)
+*/
+void TrackManager::joinV(int count, int* trackIDs)
+{
+
+}
+
+// RUNTIME //
+
+/**
+   \brief calculates the Position for the localTime of the Track.
+   \returns the calculated Position
+*/
+Vector TrackManager::calcPos()
+{
+
+}
+
+/**
+   \brief calculates the Rotation for the localTime of the Track.
+   \returns the calculated Rotation
+*/
+Vector TrackManager::calcDir()
+{
+
+}
+
+/**
+   \brief Advances the local-time of the Track around dt
+   \param dt The time about which to advance.
+*/
+void TrackManager::tick(float dt)
+{
+
+}
+
+/**
+   \brief a Function that decides which Path we should follow.
+   \param graphID The Path to choose.
+   
+*/
+void TrackManager::choosePath(int graphID)
+{
+
+}
+

orxonox/branches/parenting/src/track_manager.h

@@ -15 +15 @@
 
 
+//! 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:
@@ -21 +82 @@
   ~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);
 
 };