Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/trunk/src/modules/gametypes/SpaceRaceController.cc @ 11071

Last change on this file since 11071 was 11071, checked in by landauf, 8 years ago

merged branch cpp11_v3 back to trunk
  • 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.