Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/Racingbot/src/modules/gametypes/SpaceRaceController.cc @ 9508

Last change on this file since 9508 was 9508, checked in by purgham, 11 years ago

still not working!
File size: 23.7 KB
Line 
1/*
2 *   ORXONOX - the hottest 3D action shooter ever to exist
3 *                    > www.orxonox.net <
4 *
5 *
6 *   License notice:
7 *
8 *   This program is free software; you can redistribute it and/or
9 *   modify it under the terms of the GNU General Public License
10 *   as published by the Free Software Foundation; either version 2
11 *   of the License, or (at your option) any later version.
12 *
13 *   This program is distributed in the hope that it will be useful,
14 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
15 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 *   GNU General Public License for more details.
17 *
18 *   You should have received a copy of the GNU General Public License
19 *   along with this program; if not, write to the Free Software
20 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
21 *
22 *  Created on: Oct 8, 2012
23 *      Author: purgham
24 */
25
26/**
27 * Conventions:
28 * -first Checkpoint has index 0
29 * -staticCheckPoint= static Point (see def over = constructor)
30 */
31
32/*TODO:
33 * tICK KORRIGIEREN
34 *
35 *
36 */
37#include <gametypes/SpaceRaceController.h>
38#include "core/CoreIncludes.h"
39#include "core/XMLPort.h"
40#include "gametypes/SpaceRaceManager.h"
41#include "collisionshapes/CollisionShape.h"
42#include "BulletCollision/CollisionShapes/btCollisionShape.h"
43
44namespace orxonox
45{
46    CreateFactory(SpaceRaceController);
47
48    const int ADJUSTDISTANCE = 500;
49    const int MINDISTANCE = 5;
50    /*
51     * Idea: Find static Point (checkpoints the spaceship has to reach)
52     */
53    SpaceRaceController::SpaceRaceController(BaseObject* creator) :
54        ArtificialController(creator)
55    {
56        RegisterObject(SpaceRaceController);
57        std::vector<RaceCheckPoint*> checkpoints;
58
59        virtualCheckPointIndex=-2;
60        for (ObjectList<SpaceRaceManager>::iterator it = ObjectList<SpaceRaceManager>::begin(); it!= ObjectList<SpaceRaceManager>::end(); ++it)
61        {
62            checkpoints = it->getAllCheckpoints();
63            nextRaceCheckpoint_=it->findCheckpoint(0);
64        }
65
66        OrxAssert(!checkpoints.empty(), "No Checkpoints in Level");
67        checkpoints_=checkpoints;
68
69        for( std::vector<RaceCheckPoint*>::iterator it = checkpoints.begin(); it!=checkpoints.end(); ++it)
70        {
71            std::set<int> nextCheckPoints = ((*it)->getNextCheckpoints());
72            if(!nextCheckPoints.empty()) {
73                for (std::set<int>::iterator numb = nextCheckPoints.begin(); numb!=nextCheckPoints.end(); numb++) {
74                    RaceCheckPoint* point2 = findCheckpoint((*numb));
75
76                    if(point2 != NULL)
77                        placeVirtualCheckpoints((*it), point2);
78                }
79            }
80        }
81        staticRacePoints_ = findStaticCheckpoints(checkpoints);
82        // initialisation of currentRaceCheckpoint_
83        currentRaceCheckpoint_ = NULL;
84
85        int i;
86        for (i=-2; findCheckpoint(i)!= NULL; i--){
87            continue;
88        }
89        orxout()<<"Die ANzahl der virtuellen CP betraegt: "<< (-i)-2<<endl;
90
91    }
92
93    //------------------------------
94    // functions for initialisation
95
96    void SpaceRaceController::XMLPort(Element& xmlelement, XMLPort::Mode mode)
97    {
98        SUPER(SpaceRaceController, XMLPort, xmlelement, mode);
99        XMLPortParam(ArtificialController, "accuracy", setAccuracy, getAccuracy, xmlelement, mode).defaultValues(100.0f);
100        XMLPortObject(ArtificialController, WorldEntity, "waypoints", addWaypoint, getWaypoint, xmlelement, mode);
101
102    }
103
104    /*
105     * called from constructor 'SpaceRaceController'
106     * returns a vector of static Point (checkpoints the spaceship has to reach)
107     */
108    std::vector<RaceCheckPoint*> SpaceRaceController::findStaticCheckpoints(std::vector<RaceCheckPoint*> allCheckpoints)
109    {
110        std::map<RaceCheckPoint*, int> * zaehler = new std::map<RaceCheckPoint*, int>(); // counts how many times the checkpoit was reached (for simulation)
111        for (unsigned int i = 0; i < allCheckpoints.size(); i++)
112        {
113            zaehler->insert(std::pair<RaceCheckPoint*, int>(allCheckpoints[i],0));
114        }
115        int maxWays = rekSimulationCheckpointsReached(zaehler->begin()->first, zaehler);
116
117        std::vector<RaceCheckPoint*> returnVec;
118        returnVec.clear();
119        for (std::map<RaceCheckPoint*, int>::iterator iter = zaehler->begin(); iter!= zaehler->end(); iter++)
120        {
121            if (iter->second == maxWays)
122            {
123                //returnVec.insert(allCheckpoints[1]);
124                returnVec.insert(returnVec.end(), iter->first);
125            }
126        }
127        delete zaehler;
128        return returnVec;
129    }
130
131    /*
132     * called from 'findStaticCheckpoints'
133     * return how many ways go from the given Checkpoint to the last Checkpoint (of the Game)
134     */
135    int SpaceRaceController::rekSimulationCheckpointsReached(RaceCheckPoint* currentCheckpoint, std::map<RaceCheckPoint*, int>* zaehler)
136    {
137
138        if (currentCheckpoint->isLast())
139        {// last point reached
140
141            (*zaehler)[currentCheckpoint] += 1;
142            return 1; // 1 Way form the last point to this one
143        }
144        else
145        {
146            int numberOfWays = 0; // counts number of ways from this Point to the last point
147            for (std::set<int>::iterator it = currentCheckpoint->getVirtualNextCheckpoints().begin(); it!= currentCheckpoint->getVirtualNextCheckpoints().end(); ++it)
148            {
149                if(currentCheckpoint==findCheckpoint(*it)){
150                    orxout() << currentCheckpoint->getCheckpointIndex()<<endl;
151                    continue;
152                }
153               numberOfWays += rekSimulationCheckpointsReached(findCheckpoint(*it), zaehler);
154            }
155            (*zaehler)[currentCheckpoint] += numberOfWays;
156            return numberOfWays; // returns the number of ways from this point to the last one
157        }
158    }
159
160    //-------------------------------------
161    // functions for dynamic Way-search
162
163    int SpaceRaceController::distanceSpaceshipToCheckPoint(RaceCheckPoint* CheckPoint)
164    {
165        if (this->getControllableEntity() != NULL)
166        {
167            return (CheckPoint->getPosition()- this->getControllableEntity()->getPosition()).length();
168        }
169        return -1;
170    }
171
172    /*
173     * called by: 'tick' or  'adjustNextPoint'
174     * returns the next Checkpoint which the shortest way contains
175     */
176    RaceCheckPoint* SpaceRaceController::nextPointFind(RaceCheckPoint* raceCheckpoint)
177    {
178        int distances[] =
179        {   -1, -1, -1};
180        int temp_i = 0;
181        for (std::set<int>::iterator it =raceCheckpoint->getVirtualNextCheckpoints().begin(); it!= raceCheckpoint->getVirtualNextCheckpoints().end(); ++it)
182        {
183            distances[temp_i] = recCalculateDistance(findCheckpoint(*it), this->getControllableEntity()->getPosition());
184            temp_i++;
185        }
186        if (distances[0] > distances[1] && distances[1] != -1)
187        {
188            if (distances[2] < distances[1] && distances[2] != -1)
189            {
190                return findCheckpoint(*raceCheckpoint->getVirtualNextCheckpoints().end()); // return checkpoint with ID of raceCheckpoint->getNextCheckpoints() [2]
191            }
192            else
193            {
194                std::set<int>::iterator temp = raceCheckpoint->getVirtualNextCheckpoints().begin();
195                return findCheckpoint(*(++temp)); // return [1]
196            }
197        }
198        else
199        {
200            if (distances[2] < distances[0] && distances[2] != -1)
201            {
202                return findCheckpoint(*raceCheckpoint->getVirtualNextCheckpoints().end()); // return [2]
203            }
204            else
205            {
206                return findCheckpoint(*raceCheckpoint->getVirtualNextCheckpoints().begin()); // return [0]
207            }
208        }
209    }
210
211    /*
212     * called from 'nextPointFind'
213     * returns the distance between "currentPosition" and the next static checkpoint that can be reached from "currentCheckPoint"
214     */
215    int SpaceRaceController::recCalculateDistance(RaceCheckPoint* currentCheckPoint, Vector3 currentPosition)
216    {
217        // find: looks if the currentCheckPoint is a staticCheckPoint (staticCheckPoint is the same as: static Point)
218        if (std::find(staticRacePoints_.begin(), staticRacePoints_.end(), currentCheckPoint) != staticRacePoints_.end())
219        {
220            return (currentCheckPoint->getPosition() - currentPosition).length();
221        }
222        else
223        {
224            int minimum = std::numeric_limits<int>::max();
225            for (std::set<int>::iterator it = currentCheckPoint->getVirtualNextCheckpoints().begin(); it!= currentCheckPoint->getVirtualNextCheckpoints().end(); ++it)
226            {
227                int dist_currentCheckPoint_currentPosition = static_cast<int> ((currentPosition- currentCheckPoint->getPosition()).length());
228
229                minimum= std::min(minimum, dist_currentCheckPoint_currentPosition + recCalculateDistance(findCheckpoint(*it), currentCheckPoint->getPosition()));
230                // minimum of distanz from 'currentPosition' to the next static Checkpoint
231            }
232            return minimum;
233        }
234    }
235
236    /*called by 'tick'
237     *adjust chosen way of the Spaceship every "AdjustDistance" because spaceship could be displaced through an other one
238     */
239    RaceCheckPoint* SpaceRaceController::adjustNextPoint()
240    {
241        if (currentRaceCheckpoint_ == NULL) // no Adjust possible
242
243        {
244            return nextRaceCheckpoint_;
245        }
246        if ((currentRaceCheckpoint_->getVirtualNextCheckpoints()).size() == 1) // no Adjust possible
247
248        {
249            return nextRaceCheckpoint_;
250        }
251
252        //Adjust possible
253
254        return nextPointFind(currentRaceCheckpoint_);
255    }
256
257    RaceCheckPoint* SpaceRaceController::findCheckpoint(int index) const
258    {
259        for (size_t i = 0; i < this->checkpoints_.size(); ++i)
260        if (this->checkpoints_[i]->getCheckpointIndex() == index)
261        return this->checkpoints_[i];
262        return NULL;
263    }
264
265    RaceCheckPoint* SpaceRaceController::addVirtualCheckPoint( RaceCheckPoint* previousCheckpoint, int indexFollowingCheckPoint , Vector3 virtualCheckPointPosition )
266    {
267        RaceCheckPoint* newTempRaceCheckPoint;
268        for (ObjectList<SpaceRaceManager>::iterator it = ObjectList<SpaceRaceManager>::begin(); it!= ObjectList<SpaceRaceManager>::end(); ++it){
269            newTempRaceCheckPoint = new RaceCheckPoint((*it));
270        }
271        newTempRaceCheckPoint->setVisible(false);
272        newTempRaceCheckPoint->setPosition(virtualCheckPointPosition);
273        newTempRaceCheckPoint->setCheckpointIndex(virtualCheckPointIndex);
274        newTempRaceCheckPoint->setLast(false);
275        newTempRaceCheckPoint->setNextVirtualCheckpointsAsVector3(Vector3(indexFollowingCheckPoint,-1,-1));
276
277        Vector3 temp = previousCheckpoint->getVirtualNextCheckpointsAsVector3();
278        checkpoints_.insert(checkpoints_.end(), newTempRaceCheckPoint);
279        int positionInNextCheckPoint;
280        for (int i = 0; i <3; i++)
281        {
282            if(previousCheckpoint->getVirtualNextCheckpointsAsVector3()[i] == indexFollowingCheckPoint)
283                positionInNextCheckPoint=i;
284        }
285        switch(positionInNextCheckPoint)
286        {
287            case 0: temp.x=virtualCheckPointIndex; break;
288            case 1: temp.y=virtualCheckPointIndex; break;
289            case 2: temp.z=virtualCheckPointIndex; break;
290        }
291        previousCheckpoint->setNextVirtualCheckpointsAsVector3(temp); //Existiert internes Problem bei negativen index fueer next Checkpoint
292        virtualCheckPointIndex--;
293        //OrxAssert(virtualCheckPointIndex < -1, "TO much virtual cp");
294        /*orxout()<<"id: "<< previousCheckpoint->getCheckpointIndex() <<", following:"<<indexFollowingCheckPoint<<" :       "<<temp.x<<", "<<temp.y<<", "<<temp.z<<";       ";
295        temp=previousCheckpoint->getNextCheckpointsAsVector3();
296        orxout()<<"id: "<< previousCheckpoint->getCheckpointIndex() <<":       "<<temp.x<<", "<<temp.y<<", "<<temp.z<<";       ";
297        orxout()<<endl;*/
298        return newTempRaceCheckPoint;
299    }
300
301    SpaceRaceController::~SpaceRaceController()
302    {
303        for (int i =-1; i>virtualCheckPointIndex; i--)
304        {
305            delete findCheckpoint(i);
306        }
307    }
308
309    void SpaceRaceController::tick(float dt)
310    {
311        if (this->getControllableEntity() == NULL || this->getControllableEntity()->getPlayer() == NULL )
312        {   orxout()<<this->getControllableEntity()<< " in tick"<<endl; return;}
313        //FOR virtual Checkpoints
314        if(nextRaceCheckpoint_->getCheckpointIndex() < 0)
315        {
316            if( distanceSpaceshipToCheckPoint(nextRaceCheckpoint_) < 200)
317            {
318                currentRaceCheckpoint_=nextRaceCheckpoint_;
319                nextRaceCheckpoint_ = nextPointFind(nextRaceCheckpoint_);
320                lastPositionSpaceship=this->getControllableEntity()->getPosition();
321                orxout()<< "CP "<< currentRaceCheckpoint_->getCheckpointIndex()<<" chanched to: "<< nextRaceCheckpoint_->getCheckpointIndex()<<endl;
322            }
323        }
324
325        if (nextRaceCheckpoint_->playerWasHere(this->getControllableEntity()->getPlayer()))
326        {//Checkpoint erreicht
327
328            currentRaceCheckpoint_=nextRaceCheckpoint_;
329            OrxAssert(nextRaceCheckpoint_, "next race checkpoint undefined");
330            nextRaceCheckpoint_ = nextPointFind(nextRaceCheckpoint_);
331            lastPositionSpaceship=this->getControllableEntity()->getPosition();
332            orxout()<< "CP "<< currentRaceCheckpoint_->getCheckpointIndex()<<" chanched to: "<< nextRaceCheckpoint_->getCheckpointIndex()<<endl;
333        }
334        else if ((lastPositionSpaceship-this->getControllableEntity()->getPosition()).length()/dt > ADJUSTDISTANCE)
335        {
336            nextRaceCheckpoint_ = adjustNextPoint();
337            lastPositionSpaceship=this->getControllableEntity()->getPosition();
338        }
339
340        // Abmessung fuer MINDISTANCE gut;
341        else if((lastPositionSpaceship-this->getControllableEntity()->getPosition()).length()/dt< MINDISTANCE )
342        {
343            this->moveToPosition(Vector3(rnd()*100,rnd()*100,rnd()*100));
344            this->spin();
345            //orxout(user_status) << "Mindistance reached" << std::endl;
346            return;
347        }
348        //orxout(user_status) << "dt= " << dt << ";  distance= " << (lastPositionSpaceship-this->getControllableEntity()->getPosition()).length() <<std::endl;
349        lastPositionSpaceship=this->getControllableEntity()->getPosition();
350        this->moveToPosition(nextRaceCheckpoint_->getPosition());
351    }
352
353    // True if a coordinate of 'pointToPoint' is smaller then the corresponding coordinate of 'groesse'
354    bool SpaceRaceController::vergleicheQuader(Vector3 pointToPoint, Vector3 groesse)
355    {
356        if(abs(pointToPoint.x)<groesse.x)
357        return true;
358        if(abs(pointToPoint.y)<groesse.y)
359        return true;
360        if(abs(pointToPoint.z)<groesse.z)
361        return true;
362
363    }
364
365    bool SpaceRaceController::directLinePossible(RaceCheckPoint* racepoint1, RaceCheckPoint* racepoint2,std::vector<StaticEntity*> allObjects){
366
367        Vector3 cP1ToCP2=(racepoint2->getPosition()-racepoint1->getPosition()) / (racepoint2->getPosition()-racepoint1->getPosition()).length(); //unit Vector
368        Vector3 centerCP1=racepoint1->getPosition();
369        btVector3 positionObject;
370        btScalar radiusObject;
371
372        for (std::vector<StaticEntity*>::iterator it = allObjects.begin(); it!=allObjects.end(); ++it){
373            for (int everyShape=0; (*it)->getAttachedCollisionShape(everyShape)!=0; everyShape++){
374                btCollisionShape* currentShape = (*it)->getAttachedCollisionShape(everyShape)->getCollisionShape();
375                if(currentShape == NULL)
376                    continue;
377
378                currentShape->getBoundingSphere(positionObject,radiusObject);
379                Vector3 positionObjectNonBT(positionObject.x(), positionObject.y(), positionObject.z());
380                if((powf((cP1ToCP2.dotProduct(centerCP1-positionObjectNonBT)),2)-(centerCP1-positionObjectNonBT).dotProduct(centerCP1-positionObjectNonBT)+powf(radiusObject, 2))>0){
381                    return false;
382                }
383
384            }
385        }
386        return true;
387
388    }
389
390    void SpaceRaceController::computeVirtualCheckpoint(RaceCheckPoint* racepoint1, RaceCheckPoint* racepoint2,std::vector<StaticEntity*> allObjects){
391                Vector3 cP1ToCP2=(racepoint2->getPosition()-racepoint1->getPosition()) / (racepoint2->getPosition()-racepoint1->getPosition()).length(); //unit Vector
392                Vector3 centerCP1=racepoint1->getPosition();
393                btVector3 positionObject;
394                btScalar radiusObject;
395
396                for (std::vector<StaticEntity*>::iterator it = allObjects.begin(); it!=allObjects.end(); ++it){
397                    for (int everyShape=0; (*it)->getAttachedCollisionShape(everyShape)!=0; everyShape++){
398                        btCollisionShape* currentShape = (*it)->getAttachedCollisionShape(everyShape)->getCollisionShape();
399                        if(currentShape == NULL)
400                            continue;
401
402                        currentShape->getBoundingSphere(positionObject,radiusObject);
403                        Vector3 positionObjectNonBT(positionObject.x(), positionObject.y(), positionObject.z());
404                        if((powf((cP1ToCP2.dotProduct(centerCP1-positionObjectNonBT)),2)-(centerCP1-positionObjectNonBT).dotProduct(centerCP1-positionObjectNonBT)+powf(radiusObject, 2))>0){
405                            Vector3 zufall;
406                            Vector3 objectmiddle=positionObjectNonBT;
407                            do{
408                                      zufall=Vector3(rnd(),rnd(),rnd());//random
409                            }while((zufall.crossProduct(objectmiddle-racepoint1->getPosition())).length()==0);
410
411
412                            Vector3 normalvec=zufall.crossProduct(objectmiddle-racepoint1->getPosition());
413                            // a'/b'=a/b => a' =b'*a/b
414                            float laengeNormalvec=(objectmiddle-racepoint1->getPosition()).length()/sqrt((objectmiddle-racepoint1->getPosition()).squaredLength()-radiusObject*radiusObject)*radiusObject;
415                            RaceCheckPoint* newVirtualCheckpoint=addVirtualCheckPoint(racepoint1,racepoint2->getCheckpointIndex(), objectmiddle+normalvec/normalvec.length()*laengeNormalvec);
416                            //placeVirtualCheckpoints(newVirtualCheckpoint, racepoint2);
417                            return;
418                        }
419
420                    }
421                }
422
423    }
424
425
426
427    void SpaceRaceController::placeVirtualCheckpoints(RaceCheckPoint* racepoint1, RaceCheckPoint* racepoint2)
428    {
429        Vector3 point1 = racepoint1->getPosition();
430        Vector3 point2 = racepoint2->getPosition();
431        std::vector<StaticEntity*> problematicObjects;
432
433        for (ObjectList<StaticEntity>::iterator it = ObjectList<StaticEntity>::begin(); it!= ObjectList<StaticEntity>::end(); ++it)
434        {
435
436            if (dynamic_cast<RaceCheckPoint*>(*it)!=NULL)
437            {   continue;} // does not work jet
438
439            problematicObjects.insert(problematicObjects.end(), *it);
440            //it->getScale3D();// vector fuer halbe wuerfellaenge
441        }
442
443        if(!directLinePossible(racepoint1, racepoint2, problematicObjects)) {
444            computeVirtualCheckpoint(racepoint1, racepoint2, problematicObjects);
445        }
446
447
448//
449//        do{
450//            zufall=Vector3(rnd(),rnd(),rnd());//random
451//        }while((zufall.crossProduct(objectmiddle-racepoint1->getPosition())).length()==0);
452//
453//        Vector3 normalvec=zufall.crossProduct(objectmiddle-racepoint1->getPosition());
454//        // a'/b'=a/b => a' =b'*a/b
455//        float laengeNormalvec=(objectmiddle-racepoint1->getPosition()).length()/sqrt((objectmiddle-racepoint1->getPosition()).squaredLength()-radius*radius)*radius;
456//        addVirtualCheckPoint(racepoint1,racepoint2->getCheckpointIndex(), objectmiddle+normalvec/normalvec.length()*laengeNormalvec);
457
458//        Vector3 richtungen [6];
459//        richtungen[0]= Vector3(1,0,0);
460//        richtungen[1]= Vector3(-1,0,0);
461//        richtungen[2]= Vector3(0,1,0);
462//        richtungen[3]= Vector3(0,-1,0);
463//        richtungen[4]= Vector3(0,0,1);
464//        richtungen[5]= Vector3(0,0,-1);
465//
466//        for (int i = 0; i< 6; i++)
467//        {
468//            const int STEPS=100;
469//            const float PHI=1.1;
470//            bool collision=false;
471//
472//            for (int j =0; j<STEPS; j++)
473//            {
474//                Vector3 tempPosition=(point1 - (point2-point1+richtungen[i]*PHI)*(float)j/STEPS);
475//                for (std::vector<StaticEntity*>::iterator it = problematicObjects.begin(); it!=problematicObjects.end(); ++it)
476//                {
477//                    btVector3 positionObject;
478//                    btScalar radiusObject;
479//                    if((*it)==NULL)
480//                    {   orxout()<<"Problempoint 1.1"<<endl; continue;}
481//                    //TODO: Probably it points on a wrong object
482//                    for (int everyShape=0; (*it)->getAttachedCollisionShape(everyShape)!=0; everyShape++)
483//                    {
484//                        if((*it)->getAttachedCollisionShape(everyShape)->getCollisionShape()==NULL)
485//                        {    continue;}
486//
487//                        orxout()<<"Problempoint 2.1"<<endl;
488//                        (*it)->getAttachedCollisionShape(everyShape)->getCollisionShape()->getBoundingSphere(positionObject,radiusObject);
489//                        Vector3 positionObjectNonBT(positionObject.x(), positionObject.y(), positionObject.z());
490//                        if (((tempPosition - positionObjectNonBT).length()<radiusObject) && (vergleicheQuader((tempPosition-positionObjectNonBT),(*it)->getScale3D())))
491//                        {
492//                            collision=true; break;
493//                        }
494//                    }
495//                    if(collision) break;
496//                }
497//                if(collision)break;
498//            }
499//            if(collision) continue;
500//            // no collision => possible Way
501//            for (float j =0; j<STEPS; j++)
502//            {
503//                Vector3 possiblePosition=(point1 - (point2-point1+richtungen[i]*PHI)*j/STEPS);
504//                collision=false;
505//                for(int ij=0; ij<STEPS; j++)
506//                {
507//                    Vector3 tempPosition=(possiblePosition - (point2-possiblePosition)*(float)ij/STEPS);
508//                    for (std::vector<StaticEntity*>::iterator it = problematicObjects.begin(); it!=problematicObjects.end(); ++it)
509//                    {
510//                        btVector3 positionObject;
511//                        btScalar radiusObject;
512//                        if((*it)==NULL)
513//                        {   orxout()<<"Problempoint 1"<<endl; continue;}
514//                        for (int everyShape=0; (*it)->getAttachedCollisionShape(everyShape)!=0; everyShape++)
515//                        {
516//                            if((*it)->getAttachedCollisionShape(everyShape)->getCollisionShape()==NULL)
517//                            {   orxout()<<"Problempoint 2.2"<<endl; continue;}
518//                            (*it)->getAttachedCollisionShape(everyShape)->getCollisionShape()->getBoundingSphere(positionObject,radiusObject);
519//                            Vector3 positionObjectNonBT(positionObject.x(), positionObject.y(), positionObject.z());
520//                            if (((tempPosition-positionObjectNonBT).length()<radiusObject) && (vergleicheQuader((tempPosition-positionObjectNonBT),(*it)->getScale3D())))
521//                            {
522//                                collision=true; break;
523//                            }
524//                        }
525//                        if(collision) break;
526//                    }
527//                    if(collision)break;
528//                    //addVirtualCheckPoint(racepoint1, racepoint2->getCheckpointIndex(), possiblePosition);
529//                    return;
530//                }
531//
532//            }
533//        }
534
535    }
536}
Note: See TracBrowser for help on using the repository browser.