Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/cpp11_v2/src/modules/gametypes/SpaceRaceController.cc @ 10920

Last change on this file since 10920 was 10920, checked in by landauf, 10 years ago

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