Changeset 9523 for code/branches/presentationHS12/src

Timestamp:

Dec 16, 2012, 6:07:37 PM (12 years ago)

Author:

jo

Message:

Merging the Racingbot branch into the presentationHS12 branch.

Location:

code/branches/presentationHS12

Files:

• . (modified) (1 prop)
• src/modules/gametypes/CMakeLists.txt (modified) (1 diff)
• src/modules/gametypes/GametypesPrereqs.h (modified) (1 diff)
• src/modules/gametypes/RaceCheckPoint.cc (modified) (6 diffs)
• src/modules/gametypes/RaceCheckPoint.h (modified) (2 diffs)
• src/modules/gametypes/SpaceRace.cc (modified) (2 diffs)
• src/modules/gametypes/SpaceRaceBot.cc (copied) (copied from code/branches/Racingbot/src/modules/gametypes/SpaceRaceBot.cc)
• src/modules/gametypes/SpaceRaceBot.h (copied) (copied from code/branches/Racingbot/src/modules/gametypes/SpaceRaceBot.h)
• src/modules/gametypes/SpaceRaceController.cc (copied) (copied from code/branches/Racingbot/src/modules/gametypes/SpaceRaceController.cc) (24 diffs)
• src/modules/gametypes/SpaceRaceController.h (copied) (copied from code/branches/Racingbot/src/modules/gametypes/SpaceRaceController.h) (2 diffs)
• src/modules/gametypes/SpaceRaceManager.cc (modified) (11 diffs)
• src/modules/gametypes/SpaceRaceManager.h (modified) (2 diffs)

code/branches/presentationHS12/src/modules/gametypes/CMakeLists.txt

@@ -5 +5 @@
   OldSpaceRace.cc
   OldRaceCheckPoint.cc
+  SpaceRaceBot.cc
+  SpaceRaceController.cc
 )
 

code/branches/presentationHS12/src/modules/gametypes/GametypesPrereqs.h

@@ -67 +67 @@
     class SpaceRace;
     class OldSpaceRace;
+    class SpaceRaceManager;
+    class SpaceRaceBot;
+    class SpaceRaceController;
 }
 

code/branches/presentationHS12/src/modules/gametypes/RaceCheckPoint.cc

@@ -43 +43 @@
     CreateFactory(RaceCheckPoint);
 
-    RaceCheckPoint::RaceCheckPoint(BaseObject* creator): DistanceMultiTrigger(creator), RadarViewable(creator, static_cast<WorldEntity*>(this))
+    RaceCheckPoint::RaceCheckPoint(BaseObject* creator) : DistanceMultiTrigger(creator),
+            RadarViewable(creator, static_cast<WorldEntity*> (this))
     {
         RegisterObject(RaceCheckPoint);
-
         this->setDistance(100);
         this->setBeaconMode("off");
@@ -60 +60 @@
         this->bIsLast_ = false;
         this->timeLimit_ = 0;
-        this->player_ = NULL;
-    }
-
-
-   RaceCheckPoint::~RaceCheckPoint()
-   {
-   }
+        //this->players_ = vector<PlayerInfo*>();
+
+        myPosition_= this->getPosition(); //eingefuegt
+        //orxout(user_status) << "test" << std::endl;
+    }
+
+    RaceCheckPoint::~RaceCheckPoint()
+    {
+
+    }
 
     void RaceCheckPoint::XMLPort(Element& xmlelement, XMLPort::Mode mode)
@@ -86 +89 @@
             ControllableEntity* entity = orxonox_cast<ControllableEntity*>(originator);
             if (entity)
-                this->player_ = entity->getPlayer();
+                this->players_.push_back(entity->getPlayer());
         }
     }
@@ -95 +98 @@
         if (this->timeLimit_ != 0)
         {
-            std::string message =  "You have " + multi_cast<std::string>(this->timeLimit_)
-                        + " seconds to reach the check point " + multi_cast<std::string>(this->checkpointIndex_ + 1);
+            std::string message = "You have " + multi_cast<std::string>(this->timeLimit_)
+            + " seconds to reach the check point " + multi_cast<std::string>(this->checkpointIndex_ + 1);
             this->getGametype()->getGametypeInfo()->sendAnnounceMessage(message);
             ChatManager::message(message);
@@ -102 +105 @@
     }
 
+    //Must not be called before setNextCheckpointsAsVector3 at least once has been called
+    void RaceCheckPoint::setNextVirtualCheckpointsAsVector3(const Vector3& checkpoints){
+        /*std::set<int> lastcheckpoints=this->nextCheckpoints_;
+        nextCheckpoints_.clear();
+        std::set<int>::iterator it = lastcheckpoints.begin();
+        if(checkpoints.x<-1){
+            virtualToRealCheckPoints_.insert(std::pair<int,int>(checkpoints.x,(*it)));
+            it++;
+        }
+        if(checkpoints.x!=-1)
+            this->nextCheckpoints_.insert(static_cast<int>(checkpoints.x + 0.5)); // the red number has the type double and for the cast (to int) is added 0.5 so that the cast works correctly
+
+        if(checkpoints.y<-1){
+                    virtualToRealCheckPoints_.insert(std::pair<int,int>(checkpoints.y,(*it)));
+                    it++;
+        }
+        if(checkpoints.y!=-1)
+            this->nextCheckpoints_.insert(static_cast<int>(checkpoints.y + 0.5));
+
+        if(checkpoints.z<-1){
+                    virtualToRealCheckPoints_.insert(std::pair<int,int>(checkpoints.z,(*it)));
+                    it++;
+        }
+        if(checkpoints.z!=-1)
+            this->nextCheckpoints_.insert(static_cast<int>(checkpoints.z + 0.5));*/
+        nextCheckpointsVirtual_.clear();
+        if(checkpoints.x!=-1)
+            nextCheckpointsVirtual_.insert(checkpoints.x);
+        if(checkpoints.y!=-1)
+                nextCheckpointsVirtual_.insert(checkpoints.y);
+        if(checkpoints.z!=-1)
+                nextCheckpointsVirtual_.insert(checkpoints.z);
+    }
+
     void RaceCheckPoint::setNextCheckpointsAsVector3(const Vector3& checkpoints)
     {
@@ -107 +144 @@
 
         if (checkpoints.x > -1)
-            this->nextCheckpoints_.insert(static_cast<int>(checkpoints.x + 0.5));
+        this->nextCheckpoints_.insert(static_cast<int>(checkpoints.x + 0.5)); // the red number has the type double and for the cast (to int) is added 0.5 so that the cast works correctly
         if (checkpoints.y > -1)
-            this->nextCheckpoints_.insert(static_cast<int>(checkpoints.y + 0.5));
+        this->nextCheckpoints_.insert(static_cast<int>(checkpoints.y + 0.5));
         if (checkpoints.z > -1)
-            this->nextCheckpoints_.insert(static_cast<int>(checkpoints.z + 0.5));
-    }
-
-    Vector3 RaceCheckPoint::getNextCheckpointsAsVector3() const
+        this->nextCheckpoints_.insert(static_cast<int>(checkpoints.z + 0.5));
+
+        this->nextCheckpointsVirtual_=nextCheckpoints_;
+    }
+
+    PlayerInfo* RaceCheckPoint::getPlayer(unsigned int clientID) const
+    {
+        if (players_.size() > 0)
+        {
+            for (int i = 0; i < players_.size(); i++)
+            {
+                if (this->players_[i]->getClientID() == clientID)
+                {
+                    return players_[i];
+                }
+            }
+        }
+        return NULL;
+    }
+
+    bool RaceCheckPoint::playerWasHere(PlayerInfo* player) const
+    {
+        if (players_.size() > 0)
+        {
+            for (int i = 0; i < players_.size(); i++)
+            {
+                if (this->players_[i] == player)
+                {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    Vector3 RaceCheckPoint::getNextCheckpointsAsVector3()
+    {
+        Vector3 checkpoints(-1,-1,-1); int count=0;
+        for (std::set<int>::iterator it= nextCheckpoints_.begin();it!=nextCheckpoints_.end(); it++ ){
+            switch (count)
+                        {
+                            case 0: checkpoints.x = static_cast<Ogre::Real>(*it); break;
+                            case 1: checkpoints.y = static_cast<Ogre::Real>(*it); break;
+                            case 2: checkpoints.z = static_cast<Ogre::Real>(*it); break;
+                        }
+                        ++count;
+        }
+        return checkpoints;
+        //= getVirtualNextCheckpointsAsVector3();
+        int j[3];
+        j[0]=changeVirtualToRealCheckPoint(checkpoints.x);
+        j[1]=changeVirtualToRealCheckPoint(checkpoints.y);
+        j[2]=changeVirtualToRealCheckPoint(checkpoints.z);
+
+
+        return Vector3(j[0],j[1],j[2]);
+
+
+    }
+
+    int RaceCheckPoint::changeVirtualToRealCheckPoint(int checkpointID) {
+        int temp=checkpointID;
+        while(temp<-1){
+            temp = this->virtualToRealCheckPoints_[temp];
+        }
+        return temp;
+    }
+
+
+    Vector3 RaceCheckPoint::getVirtualNextCheckpointsAsVector3() const
     {
         Vector3 checkpoints = Vector3(-1, -1, -1);
 
         size_t count = 0;
-        for (std::set<int>::iterator it = this->nextCheckpoints_.begin(); it != this->nextCheckpoints_.end(); ++it)
+        for (std::set<int>::iterator it = this->nextCheckpointsVirtual_.begin(); it != this->nextCheckpointsVirtual_.end(); ++it)
         {
             switch (count)

code/branches/presentationHS12/src/modules/gametypes/RaceCheckPoint.h

@@ -37 +37 @@
 {
     /**
-    @brief
-        The RaceCheckPoint class enables the creation of a check point to use in a SpaceRace level.
-        Don't forget to control the indexes of your check points and to set one last check point
-    */
-    class _GametypesExport RaceCheckPoint : public DistanceMultiTrigger, public RadarViewable
+     @brief
+     The RaceCheckPoint class enables the creation of a check point to use in a SpaceRace level.
+     Don't forget to control the indexes of your check points and to set one last check point
+     */
+    class _GametypesExport RaceCheckPoint: public DistanceMultiTrigger,
+            public RadarViewable
     {
         public:
@@ -50 +51 @@
 
             inline void setCheckpointIndex(int checkpointIndex)
-                { this->checkpointIndex_ = checkpointIndex; }
+            {
+                this->checkpointIndex_ = checkpointIndex;
+            }
             inline int getCheckpointIndex() const
-                { return this->checkpointIndex_; }
+            {
+                return this->checkpointIndex_;
+            }
 
             void setNextCheckpointsAsVector3(const Vector3& checkpoints);
-            Vector3 getNextCheckpointsAsVector3() const;
-            const std::set<int>& getNextCheckpoints() const
-                { return this->nextCheckpoints_; }
+            Vector3 getNextCheckpointsAsVector3();
+            Vector3 getVirtualNextCheckpointsAsVector3() const;
+            void setNextVirtualCheckpointsAsVector3(const Vector3& checkpoints);
+            int changeVirtualToRealCheckPoint(int);
 
+            const std::set<int>& getVirtualNextCheckpoints() const
+            {
+                return this->nextCheckpointsVirtual_;
+            }
+
+            const std::set<int>& getNextCheckpoints()
+            {
+                return nextCheckpoints_;
+                std::set<int> temp;
+                std::set<int> temp2=getVirtualNextCheckpoints();
+                for (std::set<int>::iterator it = temp2.begin(); it!=temp2.end(); ++it){
+                    temp.insert(changeVirtualToRealCheckPoint((*it)));
+                }
+                return temp;
+            }
             inline void setLast(bool isLast)
-                { this->bIsLast_ = isLast; }
+            {
+                this->bIsLast_ = isLast;
+            }
             inline bool isLast() const
-                { return this->bIsLast_; }
+            {
+                return this->bIsLast_;
+            }
 
             virtual void setTimelimit(float timeLimit);
             inline float getTimeLimit() const
-                { return this->timeLimit_; }
+            {
+                return this->timeLimit_;
+            }
 
-            inline PlayerInfo* getPlayer() const
-                { return this->player_; }
+            PlayerInfo* getPlayer(unsigned int clientID) const;
+
+            bool playerWasHere(PlayerInfo* ) const;
+
             inline void resetPlayer()
-                { this->player_ = NULL; }
+            {
+                this->players_.clear();
+            }
 
         protected:
+
             virtual void fire(bool bIsTriggered, BaseObject* originator);
 
             inline const WorldEntity* getWorldEntity() const
-                { return this; }
+            {
+                return this;
+            }
 
         private:
-            int checkpointIndex_;           ///< The index of this check point. The race starts with the check point with the index 0
+
+            int checkpointIndex_; ///< The index of this check point. The race starts with the check point with the index 0
             std::set<int> nextCheckpoints_; ///< the indexes of the next check points
-            bool bIsLast_;                  ///< True if this check point is the last of the level. There can be only one last check point for each level and there must be a last check point in the level.
-            float timeLimit_;               ///< The time limit (from the start of the level) to reach this check point. If the check point is reached after this time, the game ends and the player looses.
-            PlayerInfo* player_;            ///< The player that reached the checkpoint
+            bool bIsLast_; ///< True if this check point is the last of the level. There can be only one last check point for each level and there must be a last check point in the level.
+            float timeLimit_; ///< The time limit (from the start of the level) to reach this check point. If the check point is reached after this time, the game ends and the player looses.
+            std::vector<PlayerInfo*> players_; ///< The player that reached the checkpoint
+            Vector3 myPosition_;
+            std::set<int>  nextCheckpointsVirtual_;
+            std::map<int,int> virtualToRealCheckPoints_; // if virtualChepoint was inserted the original can be reconstructed
     };
 }

code/branches/presentationHS12/src/modules/gametypes/SpaceRace.cc

@@ -35 +35 @@
 #include "util/Convert.h"
 #include "util/Math.h"
-
+#include "SpaceRaceBot.h"
 #include "items/Engine.h"
 
@@ -46 +46 @@
         RegisterObject(SpaceRace);
 
+        this->botclass_ = Class(SpaceRaceBot);//ClassByString("")
         this->cantMove_ = false;
         this->bTimeIsUp_ = false;

code/branches/presentationHS12/src/modules/gametypes/SpaceRaceController.cc

@@ -42 +42 @@
 #include "BulletCollision/CollisionShapes/btCollisionShape.h"
 
+
 namespace orxonox
 {
@@ -57 +58 @@
 ;        std::vector<RaceCheckPoint*> checkpoints;
 
-        virtualCheckPointIndex=-2;
-        for (ObjectList<SpaceRaceManager>::iterator it = ObjectList<SpaceRaceManager>::begin(); it!= ObjectList<SpaceRaceManager>::end(); ++it)
+        virtualCheckPointIndex = -2;
+        for (ObjectList<SpaceRaceManager>::iterator it = ObjectList<SpaceRaceManager>::begin(); it != ObjectList<SpaceRaceManager>::end(); ++it)
         {
             checkpoints = it->getAllCheckpoints();
-            nextRaceCheckpoint_=it->findCheckpoint(0);
+            nextRaceCheckpoint_ = it->findCheckpoint(0);
         }
 
         OrxAssert(!checkpoints.empty(), "No Checkpoints in Level");
-        checkpoints_=checkpoints;
+        checkpoints_ = checkpoints;
         /*orxout()<<"es gibt: "<<checkpoints_.size()<<"checkpoints"<<endl;
         for(std::vector<RaceCheckPoint*>::iterator it=checkpoints_.begin(); it!=checkpoints_.end(); it++)
@@ -86 +87 @@
         }//ausgabe*/
 
-        for( std::vector<RaceCheckPoint*>::iterator it = checkpoints.begin(); it!=checkpoints.end(); ++it)
+        for (std::vector<RaceCheckPoint*>::iterator it = checkpoints.begin(); it != checkpoints.end(); ++it)
         {
             std::set<int> nextCheckPoints = ((*it)->getNextCheckpoints());
@@ -95 +96 @@
                     RaceCheckPoint* point2 = findCheckpoint((*numb));
 
-                    if(point2 != NULL)
-                    placeVirtualCheckpoints((*it), point2);
+                    //if(point2 != NULL)
+                    //placeVirtualCheckpoints((*it), point2);
                 }
             }
@@ -124 +125 @@
 
         int i;
-        for (i=-2; findCheckpoint(i)!= NULL; i--)
+        for (i = -2; findCheckpoint(i) != NULL; i--)
         {
             continue;
@@ -140 +141 @@
         XMLPortParam(ArtificialController, "accuracy", setAccuracy, getAccuracy, xmlelement, mode).defaultValues(100.0f);
         XMLPortObject(ArtificialController, WorldEntity, "waypoints", addWaypoint, getWaypoint, xmlelement, mode);
-
     }
 
@@ -149 +149 @@
     std::vector<RaceCheckPoint*> SpaceRaceController::findStaticCheckpoints(std::vector<RaceCheckPoint*> allCheckpoints)
     {
-        std::map<RaceCheckPoint*, int> * zaehler = new std::map<RaceCheckPoint*, int>(); // counts how many times the checkpoit was reached (for simulation)
+        std::map<RaceCheckPoint*, int> * zaehler = new std::map<RaceCheckPoint*, int>(); // counts how many times the checkpoint was reached (for simulation)
         for (unsigned int i = 0; i < allCheckpoints.size(); i++)
         {
@@ -158 +158 @@
         std::vector<RaceCheckPoint*> returnVec;
         returnVec.clear();
-        for (std::map<RaceCheckPoint*, int>::iterator iter = zaehler->begin(); iter!= zaehler->end(); iter++)
+        for (std::map<RaceCheckPoint*, int>::iterator iter = zaehler->begin(); iter != zaehler->end(); iter++)
         {
             if (iter->second == maxWays)
@@ -188 +188 @@
             for (std::set<int>::iterator it = currentCheckpoint->getVirtualNextCheckpoints().begin(); it!= currentCheckpoint->getVirtualNextCheckpoints().end(); ++it)
             {
-                if(currentCheckpoint==findCheckpoint(*it))
+                if(currentCheckpoint == findCheckpoint(*it))
                 {
                     //orxout() << currentCheckpoint->getCheckpointIndex()<<endl;
                     continue;
                 }
-                if(findCheckpoint(*it)==NULL){orxout()<<"Problematic Point: "<<(*it)<<endl;}
+                if(findCheckpoint(*it) == NULL)
+                    {orxout()<<"Problematic Point: "<<(*it)<<endl;}
                 numberOfWays += rekSimulationCheckpointsReached(findCheckpoint(*it), zaehler);
             }
@@ -219 +220 @@
     RaceCheckPoint* SpaceRaceController::nextPointFind(RaceCheckPoint* raceCheckpoint)
     {
-        int distances[] =
-        {   -1, -1, -1};
+        int distances[] = {-1, -1, -1};
         int temp_i = 0;
         for (std::set<int>::iterator it =raceCheckpoint->getVirtualNextCheckpoints().begin(); it!= raceCheckpoint->getVirtualNextCheckpoints().end(); ++it)
@@ -266 +266 @@
         {
             int minimum = std::numeric_limits<int>::max();
-            for (std::set<int>::iterator it = currentCheckPoint->getVirtualNextCheckpoints().begin(); it!= currentCheckPoint->getVirtualNextCheckpoints().end(); ++it)
+            for (std::set<int>::iterator it = currentCheckPoint->getVirtualNextCheckpoints().begin(); it != currentCheckPoint->getVirtualNextCheckpoints().end(); ++it)
             {
                 int dist_currentCheckPoint_currentPosition = static_cast<int> ((currentPosition- currentCheckPoint->getPosition()).length());
 
-                minimum= std::min(minimum, dist_currentCheckPoint_currentPosition + recCalculateDistance(findCheckpoint(*it), currentCheckPoint->getPosition()));
+                minimum = std::min(minimum, dist_currentCheckPoint_currentPosition + recCalculateDistance(findCheckpoint(*it), currentCheckPoint->getPosition()));
                 // minimum of distanz from 'currentPosition' to the next static Checkpoint
             }
@@ -306 +306 @@
     }
 
-    RaceCheckPoint* SpaceRaceController::addVirtualCheckPoint( RaceCheckPoint* previousCheckpoint, int indexFollowingCheckPoint , Vector3 virtualCheckPointPosition )
+    /*RaceCheckPoint* SpaceRaceController::addVirtualCheckPoint( RaceCheckPoint* previousCheckpoint, int indexFollowingCheckPoint , Vector3 virtualCheckPointPosition )
     {
         orxout()<<"add VCP at"<<virtualCheckPointPosition.x<<", "<<virtualCheckPointPosition.y<<", "<<virtualCheckPointPosition.z<<endl;
@@ -343 +343 @@
          temp=previousCheckpoint->getNextCheckpointsAsVector3();
          orxout()<<"id: "<< previousCheckpoint->getCheckpointIndex() <<":       "<<temp.x<<", "<<temp.y<<", "<<temp.z<<";       ";
-         orxout()<<endl;*/
+         orxout()<<endl;*//*
         return newTempRaceCheckPoint;
-    }
+    }*/
 
     SpaceRaceController::~SpaceRaceController()
@@ -358 +358 @@
     {
         if (this->getControllableEntity() == NULL || this->getControllableEntity()->getPlayer() == NULL )
-        {   orxout()<<this->getControllableEntity()<< " in tick"<<endl; return;}
+        {
+            //orxout()<< this->getControllableEntity() << " in tick"<<endl;
+            return;
+        }
         //FOR virtual Checkpoints
         if(nextRaceCheckpoint_->getCheckpointIndex() < 0)
@@ -374 +377 @@
         {//Checkpoint erreicht
 
-            currentRaceCheckpoint_=nextRaceCheckpoint_;
+            currentRaceCheckpoint_ = nextRaceCheckpoint_;
             OrxAssert(nextRaceCheckpoint_, "next race checkpoint undefined");
             nextRaceCheckpoint_ = nextPointFind(nextRaceCheckpoint_);
-            lastPositionSpaceship=this->getControllableEntity()->getPosition();
+            lastPositionSpaceship = this->getControllableEntity()->getPosition();
             //orxout()<< "CP "<< currentRaceCheckpoint_->getCheckpointIndex()<<" chanched to: "<< nextRaceCheckpoint_->getCheckpointIndex()<<endl;
         }
@@ -383 +386 @@
         {
             nextRaceCheckpoint_ = adjustNextPoint();
-            lastPositionSpaceship=this->getControllableEntity()->getPosition();
+            lastPositionSpaceship = this->getControllableEntity()->getPosition();
         }
 
         // Abmessung fuer MINDISTANCE gut;
 
-        else if((lastPositionSpaceship-this->getControllableEntity()->getPosition()).length()/dt< MINDISTANCE )
-        {
-            this->moveToPosition(Vector3(rnd()*100,rnd()*100,rnd()*100));
+        else if((lastPositionSpaceship - this->getControllableEntity()->getPosition()).length()/dt < MINDISTANCE )
+        {
+            this->moveToPosition(Vector3(rnd()*100, rnd()*100, rnd()*100));
             this->spin();
             //orxout(user_status) << "Mindistance reached" << std::endl;
@@ -396 +399 @@
         }
         //orxout(user_status) << "dt= " << dt << ";  distance= " << (lastPositionSpaceship-this->getControllableEntity()->getPosition()).length() <<std::endl;
-        lastPositionSpaceship=this->getControllableEntity()->getPosition();
+        lastPositionSpaceship = this->getControllableEntity()->getPosition();
         this->moveToPosition(nextRaceCheckpoint_->getPosition());
     }
@@ -403 +406 @@
     bool SpaceRaceController::vergleicheQuader(Vector3 pointToPoint, Vector3 groesse)
     {
-        if(abs(pointToPoint.x)<groesse.x)
-        return true;
-        if(abs(pointToPoint.y)<groesse.y)
-        return true;
-        if(abs(pointToPoint.z)<groesse.z)
-        return true;
+        if(abs(pointToPoint.x) < groesse.x)
+            return true;
+        if(abs(pointToPoint.y) < groesse.y)
+            return true;
+        if(abs(pointToPoint.z) < groesse.z)
+            return true;
+        return false;
 
     }
@@ -415 +419 @@
     {
 
-        Vector3 cP1ToCP2=(racepoint2->getPosition()-racepoint1->getPosition()) / (racepoint2->getPosition()-racepoint1->getPosition()).length(); //unit Vector
-        Vector3 centerCP1=racepoint1->getPosition();
+        Vector3 cP1ToCP2 = (racepoint2->getPosition() - racepoint1->getPosition()) / (racepoint2->getPosition() - racepoint1->getPosition()).length(); //unit Vector
+        Vector3 centerCP1 = racepoint1->getPosition();
         btVector3 positionObject;
         btScalar radiusObject;
 
-        for (std::vector<StaticEntity*>::iterator it = allObjects.begin(); it!=allObjects.end(); ++it)
-        {
-            for (int everyShape=0; (*it)->getAttachedCollisionShape(everyShape)!=0; everyShape++)
+        for (std::vector<StaticEntity*>::iterator it = allObjects.begin(); it != allObjects.end(); ++it)
+        {
+            for (int everyShape=0; (*it)->getAttachedCollisionShape(everyShape) != 0; everyShape++)
             {
                 btCollisionShape* currentShape = (*it)->getAttachedCollisionShape(everyShape)->getCollisionShape();
@@ -441 +445 @@
     }
 
-    void SpaceRaceController::computeVirtualCheckpoint(RaceCheckPoint* racepoint1, RaceCheckPoint* racepoint2,std::vector<StaticEntity*> allObjects)
+    /*void SpaceRaceController::computeVirtualCheckpoint(RaceCheckPoint* racepoint1, RaceCheckPoint* racepoint2, std::vector<StaticEntity*> allObjects)
     {
         Vector3 cP1ToCP2=(racepoint2->getPosition()-racepoint1->getPosition()) / (racepoint2->getPosition()-racepoint1->getPosition()).length(); //unit Vector
@@ -448 +452 @@
         btScalar radiusObject;
 
-        for (std::vector<StaticEntity*>::iterator it = allObjects.begin(); it!=allObjects.end(); ++it)
-        {
-            for (int everyShape=0; (*it)->getAttachedCollisionShape(everyShape)!=0; everyShape++)
+        for (std::vector<StaticEntity*>::iterator it = allObjects.begin(); it != allObjects.end(); ++it)
+        {
+            for (int everyShape=0; (*it)->getAttachedCollisionShape(everyShape) != 0; everyShape++)
             {
                 btCollisionShape* currentShape = (*it)->getAttachedCollisionShape(everyShape)->getCollisionShape();
@@ -458 +462 @@
                 currentShape->getBoundingSphere(positionObject,radiusObject);
                 Vector3 positionObjectNonBT(positionObject.x(), positionObject.y(), positionObject.z());
-                if((powf((cP1ToCP2.dotProduct(centerCP1-positionObjectNonBT)),2)-(centerCP1-positionObjectNonBT).dotProduct(centerCP1-positionObjectNonBT)+powf(radiusObject, 2))>0)
-                {
-                    Vector3 zufall;
-                    Vector3 objectmiddle=positionObjectNonBT;
-                    do
-                    {
+                                Vector3 norm_r_CP = cP1ToCP2.crossProduct(centerCP1-positionObjectNonBT);
+
+                                if(norm_r_CP.length() == 0){
+                                        Vector3 zufall;
+                    do{
                         zufall=Vector3(rnd(),rnd(),rnd());//random
-                    }while((zufall.crossProduct(objectmiddle-racepoint1->getPosition())).length()==0);
-
-                    Vector3 normalvec=zufall.crossProduct(objectmiddle-racepoint1->getPosition());
-                    // a'/b'=a/b => a' =b'*a/b
-                    float laengeNormalvec=(objectmiddle-racepoint1->getPosition()).length()/sqrt((objectmiddle-racepoint1->getPosition()).squaredLength()-radiusObject*radiusObject)*radiusObject;
-                    RaceCheckPoint* newVirtualCheckpoint=addVirtualCheckPoint(racepoint1,racepoint2->getCheckpointIndex(), objectmiddle+normalvec/normalvec.length()*laengeNormalvec);
-                    //placeVirtualCheckpoints(newVirtualCheckpoint, racepoint2);
-                    return;
-                }
-
-            }
-        }
-
-    }
-
-    void SpaceRaceController::placeVirtualCheckpoints(RaceCheckPoint* racepoint1, RaceCheckPoint* racepoint2)
+                    }while((zufall.crossProduct(cP1ToCP2)).length() == 0);
+                                        norm_r_CP=zufall.crossProduct(cP1ToCP2);
+                                }
+                                Vector3 VecToVCP = norm_r_CP.crossProduct(cP1ToCP2);
+                                float distanzToCP1 = sqrt(powf(radiusObject,4)/(powf((centerCP1-positionObjectNonBT).length(), 2)-powf(radiusObject,2))+powf(radiusObject,2));
+                                float distanzToCP2 = sqrt(powf(radiusObject,4)/(powf((racepoint2->getPosition()-positionObjectNonBT).length(), 2)-powf(radiusObject,2))+powf(radiusObject,2));
+                float distanz = std::max(distanzToCP1,distanzToCP2);
+                                //float distanz = 0.0f; //TEMPORARY
+                                Vector3 newCheckpointPositionPos = positionObjectNonBT+(distanz*VecToVCP)/VecToVCP.length();
+                                Vector3 newCheckpointPositionNeg = positionObjectNonBT-(distanz*VecToVCP)/VecToVCP.length();
+                                if((newCheckpointPositionPos - centerCP1).length() + (newCheckpointPositionPos - (centerCP1+cP1ToCP2)).length() < (newCheckpointPositionNeg - centerCP1).length() + (newCheckpointPositionNeg - (centerCP1+cP1ToCP2)).length() )
+                                {
+                                        RaceCheckPoint* newVirtualCheckpoint = addVirtualCheckPoint(racepoint1,racepoint2->getCheckpointIndex(), newCheckpointPositionPos);
+                                }
+                                else
+                                {
+                                        RaceCheckPoint* newVirtualCheckpoint = addVirtualCheckPoint(racepoint1,racepoint2->getCheckpointIndex(), newCheckpointPositionNeg);
+                                }
+                                return;
+            }
+        }
+
+    }*/
+
+    /*void SpaceRaceController::placeVirtualCheckpoints(RaceCheckPoint* racepoint1, RaceCheckPoint* racepoint2)
     {
         Vector3 point1 = racepoint1->getPosition();
@@ -489 +501 @@
         {
 
-            if (dynamic_cast<RaceCheckPoint*>(*it)!=NULL)
-            {   continue;} // does not work jet
+            if (dynamic_cast<RaceCheckPoint*>(*it) != NULL)
+            {
+                continue;
+            } // does not work jet
 
             problematicObjects.insert(problematicObjects.end(), *it);
@@ -589 +603 @@
         //        }
 
-    }
+    }*/
 }

code/branches/presentationHS12/src/modules/gametypes/SpaceRaceController.h

@@ -32 +32 @@
 #include "gametypes/Gametype.h"
 #include "gametypes/RaceCheckPoint.h"
+#include "util/Math.h"
 
 namespace orxonox
@@ -57 +58 @@
             // same as SpaceRaceManager, but needed to add virtuell Checkpoints ( Checkpoints which don't exist but needed to avoid collisions with big Objects)
             RaceCheckPoint* findCheckpoint(int index) const;
-            RaceCheckPoint
-                    * addVirtualCheckPoint(RaceCheckPoint*, int , Vector3);
-            void placeVirtualCheckpoints(RaceCheckPoint*, RaceCheckPoint*);
+            //RaceCheckPoint * addVirtualCheckPoint(RaceCheckPoint*, int , Vector3);
+            //void placeVirtualCheckpoints(RaceCheckPoint*, RaceCheckPoint*);
             bool vergleicheQuader(Vector3, Vector3);
             bool directLinePossible(RaceCheckPoint*, RaceCheckPoint*, std::vector<StaticEntity*>);
-            void computeVirtualCheckpoint(RaceCheckPoint*, RaceCheckPoint*, std::vector<StaticEntity*>);
+            //void computeVirtualCheckpoint(RaceCheckPoint*, RaceCheckPoint*, std::vector<StaticEntity*>);
 
         public:

code/branches/presentationHS12/src/modules/gametypes/SpaceRaceManager.cc

@@ -38 +38 @@
 #include "util/Math.h"
 
-
-
 namespace orxonox
 {
     CreateFactory(SpaceRaceManager);
 
-    SpaceRaceManager::SpaceRaceManager(BaseObject* creator) : BaseObject(creator)
+    SpaceRaceManager::SpaceRaceManager(BaseObject* creator) :
+        BaseObject(creator)
     {
         RegisterObject(SpaceRaceManager);
-
+        this->race_ = orxonox_cast<SpaceRace*>(this->getGametype().get());
+        assert(race_);
+        //amountOfPlayers=(race_->getPlayers()).size();
         this->firstcheckpointvisible_ = false;
     }
@@ -54 +55 @@
     {
         for (size_t i = 0; i < this->checkpoints_.size(); ++i)
-            this->checkpoints_[i]->destroy();
+        this->checkpoints_[i]->destroy();
     }
 
@@ -61 +62 @@
         SUPER(SpaceRaceManager, XMLPort, xmlelement, mode);
 
-        XMLPortObject(SpaceRaceManager, RaceCheckPoint, "checkpoints", addCheckpoint, getCheckpoint,  xmlelement, mode);
+        XMLPortObject(SpaceRaceManager, RaceCheckPoint, "checkpoints", addCheckpoint, getCheckpoint, xmlelement, mode);
     }
 
@@ -67 +68 @@
     {
         SUPER(SpaceRaceManager,tick,dt);
+
+        this->players_ = this->race_->getPlayers();
 
         if (this->checkpoints_[0] != NULL && !this->firstcheckpointvisible_)
@@ -74 +77 @@
         }
 
-        for (size_t i = 0; i < this->checkpoints_.size(); ++i)
+        for ( std::map< PlayerInfo*, Player>::iterator it = players_.begin(); it != players_.end(); ++it)
         {
-            if (this->checkpoints_[i]->getPlayer() != NULL)
-                this->checkpointReached(this->checkpoints_[i], this->checkpoints_[i]->getPlayer());
+
+            for (size_t i = 0; i < this->checkpoints_.size(); ++i)
+            {
+                if (this->checkpoints_[i]->playerWasHere(it->first)){
+                this->checkpointReached(this->checkpoints_[i], it->first /*this->checkpoints_[i]->getPlayer()*/);
+                }
+            }
         }
+
     }
 
@@ -89 +98 @@
     {
         if (index < this->checkpoints_.size())
-            return this->checkpoints_[index];
+        return this->checkpoints_[index];
         else
-            return 0;
+        return 0;
+    }
+
+    std::vector<RaceCheckPoint*> SpaceRaceManager::getAllCheckpoints()
+    {
+        return checkpoints_;
     }
 
     /**
-        @brief Returns the checkpoint with the given checkpoint-index (@see RaceCheckPoint::getCheckpointIndex).
-    */
+     @brief Returns the checkpoint with the given checkpoint-index (@see RaceCheckPoint::getCheckpointIndex).
+     */
     RaceCheckPoint* SpaceRaceManager::findCheckpoint(int index) const
     {
         for (size_t i = 0; i < this->checkpoints_.size(); ++i)
-            if (this->checkpoints_[i]->getCheckpointIndex() == index)
-                return this->checkpoints_[i];
+        if (this->checkpoints_[i]->getCheckpointIndex() == index)
+        return this->checkpoints_[i];
         return 0;
     }
@@ -107 +121 @@
     bool SpaceRaceManager::reachedValidCheckpoint(RaceCheckPoint* oldCheckpoint, RaceCheckPoint* newCheckpoint, PlayerInfo* player) const
     {
-        if (oldCheckpoint)
+        if (oldCheckpoint != NULL)
         {
             // the player already visited an old checkpoint; see which checkpoints are possible now
             const std::set<int>& possibleCheckpoints = oldCheckpoint->getNextCheckpoints();
             for (std::set<int>::const_iterator it = possibleCheckpoints.begin(); it != possibleCheckpoints.end(); ++it)
-                if (this->findCheckpoint(*it) == newCheckpoint)
-                    return true;
+            if (this->findCheckpoint(*it) == newCheckpoint)
+            return true;
             return false;
         }
@@ -128 +142 @@
         assert(gametype);
         if (!gametype)
-            return;
+        return;
 
-        RaceCheckPoint* oldCheckpoint = gametype->getCheckpointReached(player);
+        RaceCheckPoint* oldCheckpoint = gametype->getCheckpointReached(player); // returns the last from player reached checkpoint
 
         if (this->reachedValidCheckpoint(oldCheckpoint, newCheckpoint, player))
@@ -152 +166 @@
                 // adjust the radarvisibility
                 gametype->newCheckpointReached(newCheckpoint, player);
-                this->updateRadarVisibility(oldCheckpoint, newCheckpoint);
+                if(player->isHumanPlayer())
+                    this->updateRadarVisibility(oldCheckpoint, newCheckpoint);
             }
         }
 
-        newCheckpoint->resetPlayer();
+        // newCheckpoint->resetPlayer(); loescht playerpointer TODO: check if problems occur
     }
 
@@ -165 +180 @@
             const std::set<int>& oldVisible = oldCheckpoint->getNextCheckpoints();
             for (std::set<int>::const_iterator it = oldVisible.begin(); it != oldVisible.end(); ++it)
-                this->findCheckpoint(*it)->setRadarVisibility(false);
+            this->findCheckpoint(*it)->setRadarVisibility(false);
         }
 
@@ -174 +189 @@
             const std::set<int>& newVisible = newCheckpoint->getNextCheckpoints();
             for (std::set<int>::const_iterator it = newVisible.begin(); it != newVisible.end(); ++it)
-                this->findCheckpoint(*it)->setRadarVisibility(true);
+            this->findCheckpoint(*it)->setRadarVisibility(true);
         }
     }

code/branches/presentationHS12/src/modules/gametypes/SpaceRaceManager.h

@@ -67 +67 @@
             void checkpointReached(RaceCheckPoint* newCheckpoint, PlayerInfo* player);
 
+            std::vector<RaceCheckPoint*> getAllCheckpoints();
+
             void tick(float dt);
 
@@ -76 +78 @@
             std::vector<RaceCheckPoint*> checkpoints_;
             bool firstcheckpointvisible_; ///< true if the first check point is visible.
+            SpaceRace* race_; // needed to get the players
+            //int amountOfPlayers;
+            std::map<PlayerInfo*, Player> players_;
     };
 }