Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

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

Last change on this file since 11358 was 11358, checked in by patricwi, 3 years ago

space race merged

  • Property svn:eol-style set to native
File size: 24.5 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     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#include <gametypes/SpaceRaceController.h>
27#include "core/CoreIncludes.h"
28#include "core/XMLPort.h"
29#include "gametypes/SpaceRaceManager.h"
30#include "collisionshapes/CollisionShape.h"
31#include "BulletCollision/CollisionShapes/btCollisionShape.h"
32
33
34namespace orxonox
35{
36    RegisterClass(SpaceRaceController);
37
38    const int ADJUSTDISTANCE = 500;
39    const int MINDISTANCE = 5;
40    /*
41     * Idea: Find static Point (checkpoints the spaceship has to reach)
42     */
43    SpaceRaceController::SpaceRaceController(Context* context) :
44        ArtificialController(context)
45    {
46        RegisterObject(SpaceRaceController);
47        std::vector<RaceCheckPoint*> checkpoints;
48
49        virtualCheckPointIndex = -2;
50        if (ObjectList<SpaceRaceManager>().size() != 1)
51            orxout(internal_warning) << "Expected 1 instance of SpaceRaceManager but found " << ObjectList<SpaceRaceManager>().size() << endl;
52        for (SpaceRaceManager* manager : ObjectList<SpaceRaceManager>())
53        {
54            checkpoints = manager->getAllCheckpoints();
55            nextRaceCheckpoint_ = manager->findCheckpoint(0);
56        }
57
58        OrxAssert(!checkpoints.empty(), "No Checkpoints in Level");
59        checkpoints_ = checkpoints;
60        staticRacePoints_ = findStaticCheckpoints(nextRaceCheckpoint_, checkpoints);
61        // initialisation of currentRaceCheckpoint_
62        currentRaceCheckpoint_ = nullptr;
63
64        int i;
65        for (i = -2; findCheckpoint(i) != nullptr; i--)
66        {
67            continue;
68        }
69
70    }
71
72    //------------------------------
73    // functions for initialisation
74
75    void SpaceRaceController::XMLPort(Element& xmlelement, XMLPort::Mode mode)
76    {
77        SUPER(SpaceRaceController, XMLPort, xmlelement, mode);
78        XMLPortParam(ArtificialController, "accuracy", setAccuracy, getAccuracy, xmlelement, mode).defaultValues(100.0f);
79        XMLPortObject(ArtificialController, WorldEntity, "waypoints", addWaypoint, getWaypoint, xmlelement, mode);
80    }
81
82    /*
83     * called from constructor 'SpaceRaceController'
84     * returns a vector of static Point (checkpoints the spaceship has to reach)
85     */
86    std::vector<RaceCheckPoint*> SpaceRaceController::findStaticCheckpoints(RaceCheckPoint* currentCheckpoint, const std::vector<RaceCheckPoint*>& allCheckpoints)
87    {
88        std::map<RaceCheckPoint*, int> zaehler; // counts how many times the checkpoint was reached (for simulation)
89        for (RaceCheckPoint* checkpoint : allCheckpoints)
90        {
91            zaehler.insert(std::pair<RaceCheckPoint*, int>(checkpoint,0));
92        }
93        int maxWays = rekSimulationCheckpointsReached(currentCheckpoint, zaehler);
94
95        std::vector<RaceCheckPoint*> returnVec;
96        for (const auto& mapEntry : zaehler)
97        {
98            if (mapEntry.second == maxWays)
99            {
100                returnVec.push_back(mapEntry.first);
101            }
102        }
103        return returnVec;
104    }
105
106    /*
107     * called from 'findStaticCheckpoints'
108     * return how many ways go from the given Checkpoint to the last Checkpoint (of the Game)
109     */
110    int SpaceRaceController::rekSimulationCheckpointsReached(RaceCheckPoint* currentCheckpoint, std::map<RaceCheckPoint*, int>& zaehler)
111    {
112
113        if (currentCheckpoint->isLast())
114        {// last point reached
115
116            zaehler[currentCheckpoint] += 1;
117            return 1; // 1 Way form the last point to this one
118        }
119        else
120        {
121            int numberOfWays = 0; // counts number of ways from this Point to the last point
122            for (int checkpointIndex : currentCheckpoint->getNextCheckpoints())
123            {
124                if (currentCheckpoint == findCheckpoint(checkpointIndex))
125                {
126                    //orxout() << currentCheckpoint->getCheckpointIndex()<<endl;
127                    continue;
128                }
129                if (findCheckpoint(checkpointIndex) == nullptr)
130                    orxout(internal_warning) << "Problematic Point: " << checkpointIndex << endl;
131                else
132                    numberOfWays += rekSimulationCheckpointsReached(findCheckpoint(checkpointIndex), zaehler);
133            }
134            zaehler[currentCheckpoint] += numberOfWays;
135            return numberOfWays; // returns the number of ways from this point to the last one
136        }
137    }
138
139    //-------------------------------------
140    // functions for dynamic Way-search
141
142    float SpaceRaceController::distanceSpaceshipToCheckPoint(RaceCheckPoint* CheckPoint)
143    {
144        if (this->getControllableEntity() != nullptr)
145        {
146            return (CheckPoint->getPosition()- this->getControllableEntity()->getPosition()).length();
147        }
148        return -1;
149    }
150
151    /*
152     * called by: 'tick' or  'adjustNextPoint'
153     * returns the next Checkpoint which the shortest way contains
154     */
155    RaceCheckPoint* SpaceRaceController::nextPointFind(RaceCheckPoint* raceCheckpoint)
156    {
157        float minDistance = 0;
158        RaceCheckPoint* minNextRaceCheckPoint = nullptr;
159
160        // find the next checkpoint with the minimal distance
161        for (int checkpointIndex : raceCheckpoint->getNextCheckpoints())
162        {
163            RaceCheckPoint* nextRaceCheckPoint = findCheckpoint(checkpointIndex);
164            float distance = recCalculateDistance(nextRaceCheckPoint, this->getControllableEntity()->getPosition());
165
166            if (distance < minDistance || minNextRaceCheckPoint == nullptr)
167            {
168                minDistance = distance;
169                minNextRaceCheckPoint = nextRaceCheckPoint;
170            }
171
172        }
173
174        return minNextRaceCheckPoint;
175    }
176
177    /*
178     * called from 'nextPointFind'
179     * returns the distance between "currentPosition" and the next static checkpoint that can be reached from "currentCheckPoint"
180     */
181    float SpaceRaceController::recCalculateDistance(RaceCheckPoint* currentCheckPoint, const Vector3& currentPosition)
182    {
183        // find: looks if the currentCheckPoint is a staticCheckPoint (staticCheckPoint is the same as: static Point)
184        if (std::find(staticRacePoints_.begin(), staticRacePoints_.end(), currentCheckPoint) != staticRacePoints_.end())
185        {
186            return (currentCheckPoint->getPosition() - currentPosition).length();
187        }
188        else
189        {
190            float minimum = std::numeric_limits<float>::max();
191            for (int checkpointIndex : currentCheckPoint->getNextCheckpoints())
192            {
193                int dist_currentCheckPoint_currentPosition = static_cast<int> ((currentPosition- currentCheckPoint->getPosition()).length());
194
195                minimum = std::min(minimum, dist_currentCheckPoint_currentPosition + recCalculateDistance(findCheckpoint(checkpointIndex), currentCheckPoint->getPosition()));
196                // minimum of distanz from 'currentPosition' to the next static Checkpoint
197            }
198            return minimum;
199        }
200    }
201
202    /*called by 'tick'
203     *adjust chosen way of the Spaceship every "AdjustDistance" because spaceship could be displaced through an other one
204     */
205    RaceCheckPoint* SpaceRaceController::adjustNextPoint()
206    {
207        if (currentRaceCheckpoint_ == nullptr) // no Adjust possible
208
209        {
210            return nextRaceCheckpoint_;
211        }
212        if ((currentRaceCheckpoint_->getNextCheckpoints()).size() == 1) // no Adjust possible
213
214        {
215            return nextRaceCheckpoint_;
216        }
217
218        //Adjust possible
219
220        return nextPointFind(currentRaceCheckpoint_);
221    }
222
223    RaceCheckPoint* SpaceRaceController::findCheckpoint(int index) const
224    {
225        for (RaceCheckPoint* checkpoint : this->checkpoints_)
226            if (checkpoint->getCheckpointIndex() == index)
227                return checkpoint;
228        return nullptr;
229    }
230
231    /*RaceCheckPoint* SpaceRaceController::addVirtualCheckPoint( RaceCheckPoint* previousCheckpoint, int indexFollowingCheckPoint , const Vector3& virtualCheckPointPosition )
232    {
233        orxout()<<"add VCP at"<<virtualCheckPointPosition.x<<", "<<virtualCheckPointPosition.y<<", "<<virtualCheckPointPosition.z<<endl;
234        RaceCheckPoint* newTempRaceCheckPoint;
235        ObjectList<SpaceRaceManager> list;
236        for (ObjectList<SpaceRaceManager>::iterator it = list.begin(); it!= list.end(); ++it)
237        {
238            newTempRaceCheckPoint = new RaceCheckPoint((*it));
239        }
240        newTempRaceCheckPoint->setVisible(false);
241        newTempRaceCheckPoint->setPosition(virtualCheckPointPosition);
242        newTempRaceCheckPoint->setCheckpointIndex(virtualCheckPointIndex);
243        newTempRaceCheckPoint->setLast(false);
244        newTempRaceCheckPoint->setNextVirtualCheckpointsAsVector3(Vector3(indexFollowingCheckPoint,-1,-1));
245
246        Vector3 temp = previousCheckpoint->getVirtualNextCheckpointsAsVector3();
247        //orxout()<<"temp bei 0: ="<< temp.x<< temp.y<< temp.z<<endl;
248        checkpoints_.insert(checkpoints_.end(), newTempRaceCheckPoint);
249        int positionInNextCheckPoint;
250        for (int i = 0; i <3; i++)
251        {
252            if(previousCheckpoint->getVirtualNextCheckpointsAsVector3()[i] == indexFollowingCheckPoint)
253            positionInNextCheckPoint=i;
254        }
255        switch(positionInNextCheckPoint)
256        {
257            case 0: temp.x=virtualCheckPointIndex; break;
258            case 1: temp.y=virtualCheckPointIndex; break;
259            case 2: temp.z=virtualCheckPointIndex; break;
260        }
261        previousCheckpoint->setNextVirtualCheckpointsAsVector3(temp); //Existiert internes Problem bei negativen index fueer next Checkpoint
262        virtualCheckPointIndex--;
263        //orxout()<<"temp bei 1: ="<< temp.x<< temp.y<< temp.z<<endl;
264        //orxout()<<"temp nach ausgabe: "<<previousCheckpoint->getVirtualNextCheckpointsAsVector3().x<<previousCheckpoint->getVirtualNextCheckpointsAsVector3().y<<previousCheckpoint->getVirtualNextCheckpointsAsVector3().z<<endl;
265        //OrxAssert(virtualCheckPointIndex < -1, "TO much virtual cp");
266        orxout()<<"id: "<< previousCheckpoint->getCheckpointIndex() <<", following:"<<indexFollowingCheckPoint<<" :       "<<temp.x<<", "<<temp.y<<", "<<temp.z<<";       ";
267         temp=previousCheckpoint->getNextCheckpointsAsVector3();
268         orxout()<<"id: "<< previousCheckpoint->getCheckpointIndex() <<":       "<<temp.x<<", "<<temp.y<<", "<<temp.z<<";       ";
269         orxout()<<endl;
270        return newTempRaceCheckPoint;
271    }*/
272
273    SpaceRaceController::~SpaceRaceController()
274    {
275        if (this->isInitialized())
276        {
277            for (int i =-1; i>virtualCheckPointIndex; i--)
278                delete findCheckpoint(i);
279        }
280    }
281
282    void SpaceRaceController::tick(float dt)
283    {
284        if (this->getControllableEntity() == nullptr || this->getControllableEntity()->getPlayer() == nullptr )
285        {
286            //orxout()<< this->getControllableEntity() << " in tick"<<endl;
287            return;
288        }
289        //FOR virtual Checkpoints
290        if(nextRaceCheckpoint_->getCheckpointIndex() < 0)
291        {
292            if( distanceSpaceshipToCheckPoint(nextRaceCheckpoint_) < 200)
293            {
294                currentRaceCheckpoint_=nextRaceCheckpoint_;
295                nextRaceCheckpoint_ = nextPointFind(nextRaceCheckpoint_);
296                lastPositionSpaceship=this->getControllableEntity()->getPosition();
297                //orxout()<< "CP "<< currentRaceCheckpoint_->getCheckpointIndex()<<" chanched to: "<< nextRaceCheckpoint_->getCheckpointIndex()<<endl;
298            }
299        }
300
301        if (nextRaceCheckpoint_->playerWasHere(this->getControllableEntity()->getPlayer()))
302        {//Checkpoint erreicht
303
304            currentRaceCheckpoint_ = nextRaceCheckpoint_;
305            OrxAssert(nextRaceCheckpoint_, "next race checkpoint undefined");
306            nextRaceCheckpoint_ = nextPointFind(nextRaceCheckpoint_);
307            lastPositionSpaceship = this->getControllableEntity()->getPosition();
308            //orxout()<< "CP "<< currentRaceCheckpoint_->getCheckpointIndex()<<" chanched to: "<< nextRaceCheckpoint_->getCheckpointIndex()<<endl;
309        }
310
311        else if ((lastPositionSpaceship-this->getControllableEntity()->getPosition()).length()/dt > ADJUSTDISTANCE)
312        {
313            nextRaceCheckpoint_ = adjustNextPoint();
314            lastPositionSpaceship = this->getControllableEntity()->getPosition();
315        }
316
317        // Abmessung fuer MINDISTANCE gut;
318
319        else if((lastPositionSpaceship - this->getControllableEntity()->getPosition()).length()/dt < MINDISTANCE )
320        {
321            this->moveToPosition(Vector3(rnd()*100, rnd()*100, rnd()*100));
322            this->spin();
323            //orxout(user_status) << "Mindistance reached" << std::endl;
324            return;
325        }
326        //orxout(user_status) << "dt= " << dt << ";  distance= " << (lastPositionSpaceship-this->getControllableEntity()->getPosition()).length() <<std::endl;
327        lastPositionSpaceship = this->getControllableEntity()->getPosition();
328       
329this->boostControl();
330        this->moveToPosition(nextRaceCheckpoint_->getPosition());
331        this->boostControl();
332    }
333
334    // True if a coordinate of 'pointToPoint' is smaller then the corresponding coordinate of 'groesse'
335    bool SpaceRaceController::vergleicheQuader(const Vector3& pointToPoint, const Vector3& groesse)
336    {
337        if(std::abs(pointToPoint.x) < groesse.x)
338            return true;
339        if(std::abs(pointToPoint.y) < groesse.y)
340            return true;
341        if(std::abs(pointToPoint.z) < groesse.z)
342            return true;
343        return false;
344
345    }
346
347    bool SpaceRaceController::directLinePossible(RaceCheckPoint* racepoint1, RaceCheckPoint* racepoint2, const std::vector<StaticEntity*>& allObjects)
348    {
349
350        Vector3 cP1ToCP2 = (racepoint2->getPosition() - racepoint1->getPosition()) / (racepoint2->getPosition() - racepoint1->getPosition()).length(); //unit Vector
351        Vector3 centerCP1 = racepoint1->getPosition();
352        btVector3 positionObject;
353        btScalar radiusObject;
354
355        for (StaticEntity* object : allObjects)
356        {
357            for (int everyShape=0; object->getAttachedCollisionShape(everyShape) != nullptr; everyShape++)
358            {
359                btCollisionShape* currentShape = object->getAttachedCollisionShape(everyShape)->getCollisionShape();
360                if(currentShape == nullptr)
361                continue;
362
363                currentShape->getBoundingSphere(positionObject,radiusObject);
364                Vector3 positionObjectNonBT(positionObject.x(), positionObject.y(), positionObject.z());
365                if((powf((cP1ToCP2.dotProduct(centerCP1-positionObjectNonBT)),2)-(centerCP1-positionObjectNonBT).dotProduct(centerCP1-positionObjectNonBT)+powf(radiusObject, 2))>0)
366                {
367                    return false;
368                }
369
370            }
371        }
372        return true;
373
374    }
375
376    /*void SpaceRaceController::computeVirtualCheckpoint(RaceCheckPoint* racepoint1, RaceCheckPoint* racepoint2, const std::vector<StaticEntity*>& allObjects)
377    {
378        Vector3 cP1ToCP2=(racepoint2->getPosition()-racepoint1->getPosition()) / (racepoint2->getPosition()-racepoint1->getPosition()).length(); //unit Vector
379        Vector3 centerCP1=racepoint1->getPosition();
380        btVector3 positionObject;
381        btScalar radiusObject;
382
383        for (std::vector<StaticEntity*>::iterator it = allObjects.begin(); it != allObjects.end(); ++it)
384        {
385            for (int everyShape=0; (*it)->getAttachedCollisionShape(everyShape) != nullptr; everyShape++)
386            {
387                btCollisionShape* currentShape = (*it)->getAttachedCollisionShape(everyShape)->getCollisionShape();
388                if(currentShape == nullptr)
389                continue;
390
391                currentShape->getBoundingSphere(positionObject,radiusObject);
392                Vector3 positionObjectNonBT(positionObject.x(), positionObject.y(), positionObject.z());
393                Vector3 norm_r_CP = cP1ToCP2.crossProduct(centerCP1-positionObjectNonBT);
394
395                if(norm_r_CP.length() == 0){
396                    Vector3 zufall;
397                    do{
398                        zufall=Vector3(rnd(),rnd(),rnd());//random
399                    }while((zufall.crossProduct(cP1ToCP2)).length() == 0);
400                    norm_r_CP=zufall.crossProduct(cP1ToCP2);
401                }
402                Vector3 VecToVCP = norm_r_CP.crossProduct(cP1ToCP2);
403                float distanzToCP1 = sqrt(powf(radiusObject,4)/(powf((centerCP1-positionObjectNonBT).length(), 2)-powf(radiusObject,2))+powf(radiusObject,2));
404                float distanzToCP2 = sqrt(powf(radiusObject,4)/(powf((racepoint2->getPosition()-positionObjectNonBT).length(), 2)-powf(radiusObject,2))+powf(radiusObject,2));
405                float distanz = std::max(distanzToCP1,distanzToCP2);
406                //float distanz = 0.0f; //TEMPORARY
407                Vector3 newCheckpointPositionPos = positionObjectNonBT+(distanz*VecToVCP)/VecToVCP.length();
408                Vector3 newCheckpointPositionNeg = positionObjectNonBT-(distanz*VecToVCP)/VecToVCP.length();
409                if((newCheckpointPositionPos - centerCP1).length() + (newCheckpointPositionPos - (centerCP1+cP1ToCP2)).length() < (newCheckpointPositionNeg - centerCP1).length() + (newCheckpointPositionNeg - (centerCP1+cP1ToCP2)).length() )
410                {
411                    RaceCheckPoint* newVirtualCheckpoint = addVirtualCheckPoint(racepoint1,racepoint2->getCheckpointIndex(), newCheckpointPositionPos);
412                }
413                else
414                {
415                    RaceCheckPoint* newVirtualCheckpoint = addVirtualCheckPoint(racepoint1,racepoint2->getCheckpointIndex(), newCheckpointPositionNeg);
416                }
417                return;
418            }
419        }
420
421    }*/
422
423    /*void SpaceRaceController::placeVirtualCheckpoints(RaceCheckPoint* racepoint1, RaceCheckPoint* racepoint2)
424    {
425        Vector3 point1 = racepoint1->getPosition();
426        Vector3 point2 = racepoint2->getPosition();
427        std::vector<StaticEntity*> problematicObjects;
428
429        ObjectList<StaticEntity> list;
430        for (ObjectList<StaticEntity>::iterator it = list.begin(); it!= list.end(); ++it)
431        {
432
433            if (dynamic_cast<RaceCheckPoint*>(*it) != nullptr)
434            {
435                continue;
436            } // does not work jet
437
438            problematicObjects.insert(problematicObjects.end(), *it);
439            //it->getScale3D();// vector fuer halbe wuerfellaenge
440        }
441
442        if(!directLinePossible(racepoint1, racepoint2, problematicObjects))
443        {
444            //orxout()<<"From "<<racepoint1->getCheckpointIndex()<<" to "<<racepoint2->getCheckpointIndex()<<"produces: "<< virtualCheckPointIndex<<endl;
445            computeVirtualCheckpoint(racepoint1, racepoint2, problematicObjects);
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)==nullptr)
480        //                    {   orxout()<<"Problempoint 1.1"<<endl; continue;}
481        //                    //TODO: Probably it points on a wrong object
482        //                    for (int everyShape=0; (*it)->getAttachedCollisionShape(everyShape)!=nullptr; everyShape++)
483        //                    {
484        //                        if((*it)->getAttachedCollisionShape(everyShape)->getCollisionShape()==nullptr)
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)==nullptr)
513        //                        {   orxout()<<"Problempoint 1"<<endl; continue;}
514        //                        for (int everyShape=0; (*it)->getAttachedCollisionShape(everyShape)!=nullptr; everyShape++)
515        //                        {
516        //                            if((*it)->getAttachedCollisionShape(everyShape)->getCollisionShape()==nullptr)
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.