Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

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

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

works but its not properly coded and Position of VirtualCheckpoint bad
File size: 26.6 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        /*orxout()<<"es gibt: "<<checkpoints_.size()<<"checkpoints"<<endl;
69        for(std::vector<RaceCheckPoint*>::iterator it=checkpoints_.begin(); it!=checkpoints_.end(); it++)
70        {
71            orxout()<<"Checkpoint "<<(*it)->getCheckpointIndex()<<"; NExtReal: ";
72            std::set<int> temp =(*it)->getNextCheckpoints();
73            for (std::set<int>::iterator ii =temp.begin(); ii!=temp.end(); ii++)
74            {
75                orxout()<<(*ii)<<", ";
76            }
77
78            orxout()<<" NextVirtual: ";
79            temp=(*it)->getVirtualNextCheckpoints();
80            for (std::set<int>::iterator ii =temp.begin(); ii!=temp.end(); ii++)
81            {
82                orxout()<<(*ii)<<", ";
83            }
84            orxout()<<endl<<endl;
85
86        }//ausgabe*/
87
88        for( std::vector<RaceCheckPoint*>::iterator it = checkpoints.begin(); it!=checkpoints.end(); ++it)
89        {
90            std::set<int> nextCheckPoints = ((*it)->getNextCheckpoints());
91            if(!nextCheckPoints.empty())
92            {
93                for (std::set<int>::iterator numb = nextCheckPoints.begin(); numb!=nextCheckPoints.end(); numb++)
94                {
95                    RaceCheckPoint* point2 = findCheckpoint((*numb));
96
97                    if(point2 != NULL)
98                    placeVirtualCheckpoints((*it), point2);
99                }
100            }
101        }/*
102        for(std::vector<RaceCheckPoint*>::iterator it=checkpoints_.begin(); it!=checkpoints_.end(); it++)
103        {
104            orxout()<<"Checkpoint "<<(*it)->getCheckpointIndex()<<"; NExtReal: ";
105            std::set<int> temp =(*it)->getNextCheckpoints();
106            for (std::set<int>::iterator ii =temp.begin(); ii!=temp.end(); ii++)
107            {
108                orxout()<<(*ii)<<", ";
109            }
110
111            orxout()<<" NextVirtual: ";
112            temp=(*it)->getVirtualNextCheckpoints();
113            for (std::set<int>::iterator ii =temp.begin(); ii!=temp.end(); ii++)
114            {
115                orxout()<<(*ii)<<", ";
116            }
117            orxout()<<endl;
118
119        }//ausgabe
120        orxout()<<"es gibt: "<<checkpoints_.size()<<"checkpoints"<<endl;*/
121        staticRacePoints_ = findStaticCheckpoints(checkpoints);
122        // initialisation of currentRaceCheckpoint_
123        currentRaceCheckpoint_ = NULL;
124
125        int i;
126        for (i=-2; findCheckpoint(i)!= NULL; i--)
127        {
128            continue;
129        }
130        //orxout()<<"Die ANzahl der virtuellen CP betraegt: "<< (-i)-2<<endl;
131
132    }
133
134    //------------------------------
135    // functions for initialisation
136
137    void SpaceRaceController::XMLPort(Element& xmlelement, XMLPort::Mode mode)
138    {
139        SUPER(SpaceRaceController, XMLPort, xmlelement, mode);
140        XMLPortParam(ArtificialController, "accuracy", setAccuracy, getAccuracy, xmlelement, mode).defaultValues(100.0f);
141        XMLPortObject(ArtificialController, WorldEntity, "waypoints", addWaypoint, getWaypoint, xmlelement, mode);
142
143    }
144
145    /*
146     * called from constructor 'SpaceRaceController'
147     * returns a vector of static Point (checkpoints the spaceship has to reach)
148     */
149    std::vector<RaceCheckPoint*> SpaceRaceController::findStaticCheckpoints(std::vector<RaceCheckPoint*> allCheckpoints)
150    {
151        std::map<RaceCheckPoint*, int> * zaehler = new std::map<RaceCheckPoint*, int>(); // counts how many times the checkpoit was reached (for simulation)
152        for (unsigned int i = 0; i < allCheckpoints.size(); i++)
153        {
154            zaehler->insert(std::pair<RaceCheckPoint*, int>(allCheckpoints[i],0));
155        }
156        int maxWays = rekSimulationCheckpointsReached(zaehler->begin()->first, zaehler);
157
158        std::vector<RaceCheckPoint*> returnVec;
159        returnVec.clear();
160        for (std::map<RaceCheckPoint*, int>::iterator iter = zaehler->begin(); iter!= zaehler->end(); iter++)
161        {
162            if (iter->second == maxWays)
163            {
164                //returnVec.insert(allCheckpoints[1]);
165                returnVec.insert(returnVec.end(), iter->first);
166            }
167        }
168        delete zaehler;
169        return returnVec;
170    }
171
172    /*
173     * called from 'findStaticCheckpoints'
174     * return how many ways go from the given Checkpoint to the last Checkpoint (of the Game)
175     */
176    int SpaceRaceController::rekSimulationCheckpointsReached(RaceCheckPoint* currentCheckpoint, std::map<RaceCheckPoint*, int>* zaehler)
177    {
178
179        if (currentCheckpoint->isLast())
180        {// last point reached
181
182            (*zaehler)[currentCheckpoint] += 1;
183            return 1; // 1 Way form the last point to this one
184        }
185        else
186        {
187            int numberOfWays = 0; // counts number of ways from this Point to the last point
188            for (std::set<int>::iterator it = currentCheckpoint->getVirtualNextCheckpoints().begin(); it!= currentCheckpoint->getVirtualNextCheckpoints().end(); ++it)
189            {
190                if(currentCheckpoint==findCheckpoint(*it))
191                {
192                    //orxout() << currentCheckpoint->getCheckpointIndex()<<endl;
193                    continue;
194                }
195                if(findCheckpoint(*it)==NULL){orxout()<<"Problematic Point: "<<(*it)<<endl;}
196                numberOfWays += rekSimulationCheckpointsReached(findCheckpoint(*it), zaehler);
197            }
198            (*zaehler)[currentCheckpoint] += numberOfWays;
199            return numberOfWays; // returns the number of ways from this point to the last one
200        }
201    }
202
203    //-------------------------------------
204    // functions for dynamic Way-search
205
206    int SpaceRaceController::distanceSpaceshipToCheckPoint(RaceCheckPoint* CheckPoint)
207    {
208        if (this->getControllableEntity() != NULL)
209        {
210            return (CheckPoint->getPosition()- this->getControllableEntity()->getPosition()).length();
211        }
212        return -1;
213    }
214
215    /*
216     * called by: 'tick' or  'adjustNextPoint'
217     * returns the next Checkpoint which the shortest way contains
218     */
219    RaceCheckPoint* SpaceRaceController::nextPointFind(RaceCheckPoint* raceCheckpoint)
220    {
221        int distances[] =
222        {   -1, -1, -1};
223        int temp_i = 0;
224        for (std::set<int>::iterator it =raceCheckpoint->getVirtualNextCheckpoints().begin(); it!= raceCheckpoint->getVirtualNextCheckpoints().end(); ++it)
225        {
226            distances[temp_i] = recCalculateDistance(findCheckpoint(*it), this->getControllableEntity()->getPosition());
227            temp_i++;
228        }
229        if (distances[0] > distances[1] && distances[1] != -1)
230        {
231            if (distances[2] < distances[1] && distances[2] != -1)
232            {
233                return findCheckpoint(*raceCheckpoint->getVirtualNextCheckpoints().end()); // return checkpoint with ID of raceCheckpoint->getNextCheckpoints() [2]
234            }
235            else
236            {
237                std::set<int>::iterator temp = raceCheckpoint->getVirtualNextCheckpoints().begin();
238                return findCheckpoint(*(++temp)); // return [1]
239            }
240        }
241        else
242        {
243            if (distances[2] < distances[0] && distances[2] != -1)
244            {
245                return findCheckpoint(*raceCheckpoint->getVirtualNextCheckpoints().end()); // return [2]
246            }
247            else
248            {
249                return findCheckpoint(*raceCheckpoint->getVirtualNextCheckpoints().begin()); // return [0]
250            }
251        }
252    }
253
254    /*
255     * called from 'nextPointFind'
256     * returns the distance between "currentPosition" and the next static checkpoint that can be reached from "currentCheckPoint"
257     */
258    int SpaceRaceController::recCalculateDistance(RaceCheckPoint* currentCheckPoint, Vector3 currentPosition)
259    {
260        // find: looks if the currentCheckPoint is a staticCheckPoint (staticCheckPoint is the same as: static Point)
261        if (std::find(staticRacePoints_.begin(), staticRacePoints_.end(), currentCheckPoint) != staticRacePoints_.end())
262        {
263            return (currentCheckPoint->getPosition() - currentPosition).length();
264        }
265        else
266        {
267            int minimum = std::numeric_limits<int>::max();
268            for (std::set<int>::iterator it = currentCheckPoint->getVirtualNextCheckpoints().begin(); it!= currentCheckPoint->getVirtualNextCheckpoints().end(); ++it)
269            {
270                int dist_currentCheckPoint_currentPosition = static_cast<int> ((currentPosition- currentCheckPoint->getPosition()).length());
271
272                minimum= std::min(minimum, dist_currentCheckPoint_currentPosition + recCalculateDistance(findCheckpoint(*it), currentCheckPoint->getPosition()));
273                // minimum of distanz from 'currentPosition' to the next static Checkpoint
274            }
275            return minimum;
276        }
277    }
278
279    /*called by 'tick'
280     *adjust chosen way of the Spaceship every "AdjustDistance" because spaceship could be displaced through an other one
281     */
282    RaceCheckPoint* SpaceRaceController::adjustNextPoint()
283    {
284        if (currentRaceCheckpoint_ == NULL) // no Adjust possible
285
286        {
287            return nextRaceCheckpoint_;
288        }
289        if ((currentRaceCheckpoint_->getVirtualNextCheckpoints()).size() == 1) // no Adjust possible
290
291        {
292            return nextRaceCheckpoint_;
293        }
294
295        //Adjust possible
296
297        return nextPointFind(currentRaceCheckpoint_);
298    }
299
300    RaceCheckPoint* SpaceRaceController::findCheckpoint(int index) const
301    {
302        for (size_t i = 0; i < this->checkpoints_.size(); ++i)
303        if (this->checkpoints_[i]->getCheckpointIndex() == index)
304        return this->checkpoints_[i];
305        return NULL;
306    }
307
308    RaceCheckPoint* SpaceRaceController::addVirtualCheckPoint( RaceCheckPoint* previousCheckpoint, int indexFollowingCheckPoint , Vector3 virtualCheckPointPosition )
309    {
310        orxout()<<"add VCP at"<<virtualCheckPointPosition.x<<", "<<virtualCheckPointPosition.y<<", "<<virtualCheckPointPosition.z<<endl;
311        RaceCheckPoint* newTempRaceCheckPoint;
312        for (ObjectList<SpaceRaceManager>::iterator it = ObjectList<SpaceRaceManager>::begin(); it!= ObjectList<SpaceRaceManager>::end(); ++it)
313        {
314            newTempRaceCheckPoint = new RaceCheckPoint((*it));
315        }
316        newTempRaceCheckPoint->setVisible(false);
317        newTempRaceCheckPoint->setPosition(virtualCheckPointPosition);
318        newTempRaceCheckPoint->setCheckpointIndex(virtualCheckPointIndex);
319        newTempRaceCheckPoint->setLast(false);
320        newTempRaceCheckPoint->setNextVirtualCheckpointsAsVector3(Vector3(indexFollowingCheckPoint,-1,-1));
321
322        Vector3 temp = previousCheckpoint->getVirtualNextCheckpointsAsVector3();
323        //orxout()<<"temp bei 0: ="<< temp.x<< temp.y<< temp.z<<endl;
324        checkpoints_.insert(checkpoints_.end(), newTempRaceCheckPoint);
325        int positionInNextCheckPoint;
326        for (int i = 0; i <3; i++)
327        {
328            if(previousCheckpoint->getVirtualNextCheckpointsAsVector3()[i] == indexFollowingCheckPoint)
329            positionInNextCheckPoint=i;
330        }
331        switch(positionInNextCheckPoint)
332        {
333            case 0: temp.x=virtualCheckPointIndex; break;
334            case 1: temp.y=virtualCheckPointIndex; break;
335            case 2: temp.z=virtualCheckPointIndex; break;
336        }
337        previousCheckpoint->setNextVirtualCheckpointsAsVector3(temp); //Existiert internes Problem bei negativen index fueer next Checkpoint
338        virtualCheckPointIndex--;
339        //orxout()<<"temp bei 1: ="<< temp.x<< temp.y<< temp.z<<endl;
340        //orxout()<<"temp nach ausgabe: "<<previousCheckpoint->getVirtualNextCheckpointsAsVector3().x<<previousCheckpoint->getVirtualNextCheckpointsAsVector3().y<<previousCheckpoint->getVirtualNextCheckpointsAsVector3().z<<endl;
341        //OrxAssert(virtualCheckPointIndex < -1, "TO much virtual cp");
342        /*orxout()<<"id: "<< previousCheckpoint->getCheckpointIndex() <<", following:"<<indexFollowingCheckPoint<<" :       "<<temp.x<<", "<<temp.y<<", "<<temp.z<<";       ";
343         temp=previousCheckpoint->getNextCheckpointsAsVector3();
344         orxout()<<"id: "<< previousCheckpoint->getCheckpointIndex() <<":       "<<temp.x<<", "<<temp.y<<", "<<temp.z<<";       ";
345         orxout()<<endl;*/
346        return newTempRaceCheckPoint;
347    }
348
349    SpaceRaceController::~SpaceRaceController()
350    {
351        for (int i =-1; i>virtualCheckPointIndex; i--)
352        {
353            delete findCheckpoint(i);
354        }
355    }
356
357    void SpaceRaceController::tick(float dt)
358    {
359        if (this->getControllableEntity() == NULL || this->getControllableEntity()->getPlayer() == NULL )
360        {   orxout()<<this->getControllableEntity()<< " in tick"<<endl; return;}
361        //FOR virtual Checkpoints
362        if(nextRaceCheckpoint_->getCheckpointIndex() < 0)
363        {
364            if( distanceSpaceshipToCheckPoint(nextRaceCheckpoint_) < 200)
365            {
366                currentRaceCheckpoint_=nextRaceCheckpoint_;
367                nextRaceCheckpoint_ = nextPointFind(nextRaceCheckpoint_);
368                lastPositionSpaceship=this->getControllableEntity()->getPosition();
369                //orxout()<< "CP "<< currentRaceCheckpoint_->getCheckpointIndex()<<" chanched to: "<< nextRaceCheckpoint_->getCheckpointIndex()<<endl;
370            }
371        }
372
373        if (nextRaceCheckpoint_->playerWasHere(this->getControllableEntity()->getPlayer()))
374        {//Checkpoint erreicht
375
376            currentRaceCheckpoint_=nextRaceCheckpoint_;
377            OrxAssert(nextRaceCheckpoint_, "next race checkpoint undefined");
378            nextRaceCheckpoint_ = nextPointFind(nextRaceCheckpoint_);
379            lastPositionSpaceship=this->getControllableEntity()->getPosition();
380            //orxout()<< "CP "<< currentRaceCheckpoint_->getCheckpointIndex()<<" chanched to: "<< nextRaceCheckpoint_->getCheckpointIndex()<<endl;
381        }
382        else if ((lastPositionSpaceship-this->getControllableEntity()->getPosition()).length()/dt > ADJUSTDISTANCE)
383        {
384            nextRaceCheckpoint_ = adjustNextPoint();
385            lastPositionSpaceship=this->getControllableEntity()->getPosition();
386        }
387
388        // Abmessung fuer MINDISTANCE gut;
389
390        else if((lastPositionSpaceship-this->getControllableEntity()->getPosition()).length()/dt< MINDISTANCE )
391        {
392            this->moveToPosition(Vector3(rnd()*100,rnd()*100,rnd()*100));
393            this->spin();
394            //orxout(user_status) << "Mindistance reached" << std::endl;
395            return;
396        }
397        //orxout(user_status) << "dt= " << dt << ";  distance= " << (lastPositionSpaceship-this->getControllableEntity()->getPosition()).length() <<std::endl;
398        lastPositionSpaceship=this->getControllableEntity()->getPosition();
399        this->moveToPosition(nextRaceCheckpoint_->getPosition());
400    }
401
402    // True if a coordinate of 'pointToPoint' is smaller then the corresponding coordinate of 'groesse'
403    bool SpaceRaceController::vergleicheQuader(Vector3 pointToPoint, Vector3 groesse)
404    {
405        if(abs(pointToPoint.x)<groesse.x)
406        return true;
407        if(abs(pointToPoint.y)<groesse.y)
408        return true;
409        if(abs(pointToPoint.z)<groesse.z)
410        return true;
411
412    }
413
414    bool SpaceRaceController::directLinePossible(RaceCheckPoint* racepoint1, RaceCheckPoint* racepoint2,std::vector<StaticEntity*> allObjects)
415    {
416
417        Vector3 cP1ToCP2=(racepoint2->getPosition()-racepoint1->getPosition()) / (racepoint2->getPosition()-racepoint1->getPosition()).length(); //unit Vector
418        Vector3 centerCP1=racepoint1->getPosition();
419        btVector3 positionObject;
420        btScalar radiusObject;
421
422        for (std::vector<StaticEntity*>::iterator it = allObjects.begin(); it!=allObjects.end(); ++it)
423        {
424            for (int everyShape=0; (*it)->getAttachedCollisionShape(everyShape)!=0; everyShape++)
425            {
426                btCollisionShape* currentShape = (*it)->getAttachedCollisionShape(everyShape)->getCollisionShape();
427                if(currentShape == NULL)
428                continue;
429
430                currentShape->getBoundingSphere(positionObject,radiusObject);
431                Vector3 positionObjectNonBT(positionObject.x(), positionObject.y(), positionObject.z());
432                if((powf((cP1ToCP2.dotProduct(centerCP1-positionObjectNonBT)),2)-(centerCP1-positionObjectNonBT).dotProduct(centerCP1-positionObjectNonBT)+powf(radiusObject, 2))>0)
433                {
434                    return false;
435                }
436
437            }
438        }
439        return true;
440
441    }
442
443    void SpaceRaceController::computeVirtualCheckpoint(RaceCheckPoint* racepoint1, RaceCheckPoint* racepoint2,std::vector<StaticEntity*> allObjects)
444    {
445        Vector3 cP1ToCP2=(racepoint2->getPosition()-racepoint1->getPosition()) / (racepoint2->getPosition()-racepoint1->getPosition()).length(); //unit Vector
446        Vector3 centerCP1=racepoint1->getPosition();
447        btVector3 positionObject;
448        btScalar radiusObject;
449
450        for (std::vector<StaticEntity*>::iterator it = allObjects.begin(); it!=allObjects.end(); ++it)
451        {
452            for (int everyShape=0; (*it)->getAttachedCollisionShape(everyShape)!=0; everyShape++)
453            {
454                btCollisionShape* currentShape = (*it)->getAttachedCollisionShape(everyShape)->getCollisionShape();
455                if(currentShape == NULL)
456                continue;
457
458                currentShape->getBoundingSphere(positionObject,radiusObject);
459                Vector3 positionObjectNonBT(positionObject.x(), positionObject.y(), positionObject.z());
460                if((powf((cP1ToCP2.dotProduct(centerCP1-positionObjectNonBT)),2)-(centerCP1-positionObjectNonBT).dotProduct(centerCP1-positionObjectNonBT)+powf(radiusObject, 2))>0)
461                {
462                    Vector3 zufall;
463                    Vector3 objectmiddle=positionObjectNonBT;
464                    do
465                    {
466                        zufall=Vector3(rnd(),rnd(),rnd());//random
467                    }while((zufall.crossProduct(objectmiddle-racepoint1->getPosition())).length()==0);
468
469                    Vector3 normalvec=zufall.crossProduct(objectmiddle-racepoint1->getPosition());
470                    // a'/b'=a/b => a' =b'*a/b
471                    float laengeNormalvec=(objectmiddle-racepoint1->getPosition()).length()/sqrt((objectmiddle-racepoint1->getPosition()).squaredLength()-radiusObject*radiusObject)*radiusObject;
472                    RaceCheckPoint* newVirtualCheckpoint=addVirtualCheckPoint(racepoint1,racepoint2->getCheckpointIndex(), objectmiddle+normalvec/normalvec.length()*laengeNormalvec);
473                    //placeVirtualCheckpoints(newVirtualCheckpoint, racepoint2);
474                    return;
475                }
476
477            }
478        }
479
480    }
481
482    void SpaceRaceController::placeVirtualCheckpoints(RaceCheckPoint* racepoint1, RaceCheckPoint* racepoint2)
483    {
484        Vector3 point1 = racepoint1->getPosition();
485        Vector3 point2 = racepoint2->getPosition();
486        std::vector<StaticEntity*> problematicObjects;
487
488        for (ObjectList<StaticEntity>::iterator it = ObjectList<StaticEntity>::begin(); it!= ObjectList<StaticEntity>::end(); ++it)
489        {
490
491            if (dynamic_cast<RaceCheckPoint*>(*it)!=NULL)
492            {   continue;} // does not work jet
493
494            problematicObjects.insert(problematicObjects.end(), *it);
495            //it->getScale3D();// vector fuer halbe wuerfellaenge
496        }
497
498        if(!directLinePossible(racepoint1, racepoint2, problematicObjects))
499        {
500            //orxout()<<"From "<<racepoint1->getCheckpointIndex()<<" to "<<racepoint2->getCheckpointIndex()<<"produces: "<< virtualCheckPointIndex<<endl;
501            computeVirtualCheckpoint(racepoint1, racepoint2, problematicObjects);
502        }
503
504        //
505        //        do{
506        //            zufall=Vector3(rnd(),rnd(),rnd());//random
507        //        }while((zufall.crossProduct(objectmiddle-racepoint1->getPosition())).length()==0);
508        //
509        //        Vector3 normalvec=zufall.crossProduct(objectmiddle-racepoint1->getPosition());
510        //        // a'/b'=a/b => a' =b'*a/b
511        //        float laengeNormalvec=(objectmiddle-racepoint1->getPosition()).length()/sqrt((objectmiddle-racepoint1->getPosition()).squaredLength()-radius*radius)*radius;
512        //        addVirtualCheckPoint(racepoint1,racepoint2->getCheckpointIndex(), objectmiddle+normalvec/normalvec.length()*laengeNormalvec);
513
514        //        Vector3 richtungen [6];
515        //        richtungen[0]= Vector3(1,0,0);
516        //        richtungen[1]= Vector3(-1,0,0);
517        //        richtungen[2]= Vector3(0,1,0);
518        //        richtungen[3]= Vector3(0,-1,0);
519        //        richtungen[4]= Vector3(0,0,1);
520        //        richtungen[5]= Vector3(0,0,-1);
521        //
522        //        for (int i = 0; i< 6; i++)
523        //        {
524        //            const int STEPS=100;
525        //            const float PHI=1.1;
526        //            bool collision=false;
527        //
528        //            for (int j =0; j<STEPS; j++)
529        //            {
530        //                Vector3 tempPosition=(point1 - (point2-point1+richtungen[i]*PHI)*(float)j/STEPS);
531        //                for (std::vector<StaticEntity*>::iterator it = problematicObjects.begin(); it!=problematicObjects.end(); ++it)
532        //                {
533        //                    btVector3 positionObject;
534        //                    btScalar radiusObject;
535        //                    if((*it)==NULL)
536        //                    {   orxout()<<"Problempoint 1.1"<<endl; continue;}
537        //                    //TODO: Probably it points on a wrong object
538        //                    for (int everyShape=0; (*it)->getAttachedCollisionShape(everyShape)!=0; everyShape++)
539        //                    {
540        //                        if((*it)->getAttachedCollisionShape(everyShape)->getCollisionShape()==NULL)
541        //                        {    continue;}
542        //
543        //                        orxout()<<"Problempoint 2.1"<<endl;
544        //                        (*it)->getAttachedCollisionShape(everyShape)->getCollisionShape()->getBoundingSphere(positionObject,radiusObject);
545        //                        Vector3 positionObjectNonBT(positionObject.x(), positionObject.y(), positionObject.z());
546        //                        if (((tempPosition - positionObjectNonBT).length()<radiusObject) && (vergleicheQuader((tempPosition-positionObjectNonBT),(*it)->getScale3D())))
547        //                        {
548        //                            collision=true; break;
549        //                        }
550        //                    }
551        //                    if(collision) break;
552        //                }
553        //                if(collision)break;
554        //            }
555        //            if(collision) continue;
556        //            // no collision => possible Way
557        //            for (float j =0; j<STEPS; j++)
558        //            {
559        //                Vector3 possiblePosition=(point1 - (point2-point1+richtungen[i]*PHI)*j/STEPS);
560        //                collision=false;
561        //                for(int ij=0; ij<STEPS; j++)
562        //                {
563        //                    Vector3 tempPosition=(possiblePosition - (point2-possiblePosition)*(float)ij/STEPS);
564        //                    for (std::vector<StaticEntity*>::iterator it = problematicObjects.begin(); it!=problematicObjects.end(); ++it)
565        //                    {
566        //                        btVector3 positionObject;
567        //                        btScalar radiusObject;
568        //                        if((*it)==NULL)
569        //                        {   orxout()<<"Problempoint 1"<<endl; continue;}
570        //                        for (int everyShape=0; (*it)->getAttachedCollisionShape(everyShape)!=0; everyShape++)
571        //                        {
572        //                            if((*it)->getAttachedCollisionShape(everyShape)->getCollisionShape()==NULL)
573        //                            {   orxout()<<"Problempoint 2.2"<<endl; continue;}
574        //                            (*it)->getAttachedCollisionShape(everyShape)->getCollisionShape()->getBoundingSphere(positionObject,radiusObject);
575        //                            Vector3 positionObjectNonBT(positionObject.x(), positionObject.y(), positionObject.z());
576        //                            if (((tempPosition-positionObjectNonBT).length()<radiusObject) && (vergleicheQuader((tempPosition-positionObjectNonBT),(*it)->getScale3D())))
577        //                            {
578        //                                collision=true; break;
579        //                            }
580        //                        }
581        //                        if(collision) break;
582        //                    }
583        //                    if(collision)break;
584        //                    //addVirtualCheckPoint(racepoint1, racepoint2->getCheckpointIndex(), possiblePosition);
585        //                    return;
586        //                }
587        //
588        //            }
589        //        }
590
591    }
592}
Note: See TracBrowser for help on using the repository browser.