[Orxonox-commit 7348] r11965 - code/branches/RacingBots_FS18/src/modules/gametypes
andera at orxonox.net
andera at orxonox.net
Thu May 17 14:29:38 CEST 2018
Author: andera
Date: 2018-05-17 14:29:38 +0200 (Thu, 17 May 2018)
New Revision: 11965
Modified:
code/branches/RacingBots_FS18/src/modules/gametypes/SpaceRaceController.cc
Log:
SpaceRaceController.cc updated
Modified: code/branches/RacingBots_FS18/src/modules/gametypes/SpaceRaceController.cc
===================================================================
--- code/branches/RacingBots_FS18/src/modules/gametypes/SpaceRaceController.cc 2018-05-17 12:28:58 UTC (rev 11964)
+++ code/branches/RacingBots_FS18/src/modules/gametypes/SpaceRaceController.cc 2018-05-17 12:29:38 UTC (rev 11965)
@@ -29,6 +29,7 @@
#include "gametypes/SpaceRaceManager.h"
#include "collisionshapes/CollisionShape.h"
#include "BulletCollision/CollisionShapes/btCollisionShape.h"
+#include "SpaceRace.h"
namespace orxonox
@@ -37,6 +38,7 @@
const int ADJUSTDISTANCE = 500;
const int MINDISTANCE = 5;
+
/*
* Idea: Find static Point (checkpoints the spaceship has to reach)
*/
@@ -44,6 +46,8 @@
ArtificialController(context)
{
RegisterObject(SpaceRaceController);
+ //this->parentRace = nullptr;
+
std::vector<RaceCheckPoint*> checkpoints;
virtualCheckPointIndex = -2;
@@ -121,14 +125,15 @@
int numberOfWays = 0; // counts number of ways from this Point to the last point
for (int checkpointIndex : currentCheckpoint->getNextCheckpoints())
{
+ if (findCheckpoint(checkpointIndex) == nullptr){
+ orxout(internal_warning) << "Problematic Point: " << checkpointIndex << endl;
+ }
if (currentCheckpoint == findCheckpoint(checkpointIndex))
{
orxout() << currentCheckpoint->getCheckpointIndex()<<endl;
continue;
}
- if (findCheckpoint(checkpointIndex) == nullptr){
- orxout(internal_warning) << "Problematic Point: " << checkpointIndex << endl;
- }
+
else
numberOfWays += rekSimulationCheckpointsReached(findCheckpoint(checkpointIndex), zaehler);
@@ -169,10 +174,11 @@
{
minDistance = distance;
minNextRaceCheckPoint = nextRaceCheckPoint;
+
}
}
- if(minNextRaceCheckPoint==nullptr){orxout()<<"minNextRaceCheckPoint=nullpointer line 175 SpaceRaceController index: "<<endl;}
+ if(minNextRaceCheckPoint == nullptr) orxout()<<"nullptr found @181 SpaceRaceController" << endl;
return minNextRaceCheckPoint;
}
@@ -209,11 +215,15 @@
if (currentRaceCheckpoint_ == nullptr) // no Adjust possible
{
+ if(nextRaceCheckpoint_ == nullptr) orxout()<<"nullptr found @218 SpaceRaceController" << endl;
+
return nextRaceCheckpoint_;
}
if ((currentRaceCheckpoint_->getNextCheckpoints()).size() == 1) // no Adjust possible
{
+ if(nextRaceCheckpoint_ == nullptr) orxout()<<"nullptr found @223 SpaceRaceController" << endl;
+
return nextRaceCheckpoint_;
}
@@ -225,15 +235,58 @@
RaceCheckPoint* SpaceRaceController::findCheckpoint(int index) const
{
for (RaceCheckPoint* checkpoint : this->checkpoints_){
- if (checkpoint->getCheckpointIndex() == index)
+ //conclusion: index=20 is not
+ if (checkpoint->getCheckpointIndex() == index){
+ if(checkpoint == nullptr) orxout()<<"returned nullptr @line 234 SpaceRaceController"<<endl;
return checkpoint;
-
+ }
}
- orxout()<<"returned nullptr @line 231 SpaceRaceController"<<endl;
return nullptr;
}
+ /*RaceCheckPoint* SpaceRaceController::addVirtualCheckPoint( RaceCheckPoint* previousCheckpoint, int indexFollowingCheckPoint , const Vector3& virtualCheckPointPosition )
+ {
+ orxout()<<"add VCP at"<<virtualCheckPointPosition.x<<", "<<virtualCheckPointPosition.y<<", "<<virtualCheckPointPosition.z<<endl;
+ RaceCheckPoint* newTempRaceCheckPoint;
+ ObjectList<SpaceRaceManager> list;
+ for (ObjectList<SpaceRaceManager>::iterator it = list.begin(); it!= list.end(); ++it)
+ {
+ newTempRaceCheckPoint = new RaceCheckPoint((*it));
+ }
+ newTempRaceCheckPoint->setVisible(false);
+ newTempRaceCheckPoint->setPosition(virtualCheckPointPosition);
+ newTempRaceCheckPoint->setCheckpointIndex(virtualCheckPointIndex);
+ newTempRaceCheckPoint->setLast(false);
+ newTempRaceCheckPoint->setNextVirtualCheckpointsAsVector3(Vector3(indexFollowingCheckPoint,-1,-1));
+
+ Vector3 temp = previousCheckpoint->getVirtualNextCheckpointsAsVector3();
+ //orxout()<<"temp bei 0: ="<< temp.x<< temp.y<< temp.z<<endl;
+ checkpoints_.insert(checkpoints_.end(), newTempRaceCheckPoint);
+ int positionInNextCheckPoint;
+ for (int i = 0; i <3; i++)
+ {
+ if(previousCheckpoint->getVirtualNextCheckpointsAsVector3()[i] == indexFollowingCheckPoint)
+ positionInNextCheckPoint=i;
+ }
+ switch(positionInNextCheckPoint)
+ {
+ case 0: temp.x=virtualCheckPointIndex; break;
+ case 1: temp.y=virtualCheckPointIndex; break;
+ case 2: temp.z=virtualCheckPointIndex; break;
+ }
+ previousCheckpoint->setNextVirtualCheckpointsAsVector3(temp); //Existiert internes Problem bei negativen index fueer next Checkpoint
+ virtualCheckPointIndex--;
+ //orxout()<<"temp bei 1: ="<< temp.x<< temp.y<< temp.z<<endl;
+ //orxout()<<"temp nach ausgabe: "<<previousCheckpoint->getVirtualNextCheckpointsAsVector3().x<<previousCheckpoint->getVirtualNextCheckpointsAsVector3().y<<previousCheckpoint->getVirtualNextCheckpointsAsVector3().z<<endl;
+ //OrxAssert(virtualCheckPointIndex < -1, "TO much virtual cp");
+ orxout()<<"id: "<< previousCheckpoint->getCheckpointIndex() <<", following:"<<indexFollowingCheckPoint<<" : "<<temp.x<<", "<<temp.y<<", "<<temp.z<<"; ";
+ temp=previousCheckpoint->getNextCheckpointsAsVector3();
+ orxout()<<"id: "<< previousCheckpoint->getCheckpointIndex() <<": "<<temp.x<<", "<<temp.y<<", "<<temp.z<<"; ";
+ orxout()<<endl;
+ return newTempRaceCheckPoint;
+ }*/
+
SpaceRaceController::~SpaceRaceController()
{
if (this->isInitialized())
@@ -275,6 +328,8 @@
else if ((lastPositionSpaceship-this->getControllableEntity()->getPosition()).length()/dt > ADJUSTDISTANCE)
{
nextRaceCheckpoint_ = adjustNextPoint();
+ if(nextRaceCheckpoint_ == nullptr) orxout()<<"nullptr found @327 SpaceRaceController" << endl;
+
lastPositionSpaceship = this->getControllableEntity()->getPosition();
}
@@ -284,18 +339,36 @@
{
this->moveToPosition(Vector3(rnd()*100, rnd()*100, rnd()*100));
this->spin();
- orxout(user_status) << "Mindistance reached" << std::endl;
+ //orxout(user_status) << "Mindistance reached" << std::endl;
return;
}
//orxout(user_status) << "dt= " << dt << "; distance= " << (lastPositionSpaceship-this->getControllableEntity()->getPosition()).length() <<std::endl;
- lastPositionSpaceship = this->getControllableEntity()->getPosition();
-
+ /*lastPositionSpaceship = this->getControllableEntity()->getPosition();
+
+ SpaceRace obj=new SpaceRace();
+ obj.setParentRace(parentRace);
+ this->parentRace=obj.parentRace;*/
+
this->boostControl();
- if (nextRaceCheckpoint_ == nullptr) orxout() << "nextRaceCheckpoint_ equals to nullpointer look @line 334 SpaceRaceController.cc" << endl;
+
+ /*if(nextRaceCheckpoint_ == nullptr){
+ this->parentRace->bLost=true;
+ this->parentRace->end();
+ }*/
+ // if(nextRaceCheckpoint_ == nullptr ){
+ // // if( nextRaceCheckpoint_->getCheckpointIndex()==19)
+ // orxout()<<"nullptr @351 Line"<<endl;
+ // }
+
this->moveToPosition(nextRaceCheckpoint_->getPosition());
+
this->boostControl();
}
+
+ /*void SpaceRaceController::setParentRace(parentRace){
+ this->parentRace=parentRace;
+ }*/
// True if a coordinate of 'pointToPoint' is smaller then the corresponding coordinate of 'groesse'
bool SpaceRaceController::vergleicheQuader(const Vector3& pointToPoint, const Vector3& groesse)
{
@@ -337,4 +410,165 @@
return true;
}
+
+ /*void SpaceRaceController::computeVirtualCheckpoint(RaceCheckPoint* racepoint1, RaceCheckPoint* racepoint2, const std::vector<StaticEntity*>& allObjects)
+ {
+ Vector3 cP1ToCP2=(racepoint2->getPosition()-racepoint1->getPosition()) / (racepoint2->getPosition()-racepoint1->getPosition()).length(); //unit Vector
+ Vector3 centerCP1=racepoint1->getPosition();
+ btVector3 positionObject;
+ btScalar radiusObject;
+
+ for (std::vector<StaticEntity*>::iterator it = allObjects.begin(); it != allObjects.end(); ++it)
+ {
+ for (int everyShape=0; (*it)->getAttachedCollisionShape(everyShape) != nullptr; everyShape++)
+ {
+ btCollisionShape* currentShape = (*it)->getAttachedCollisionShape(everyShape)->getCollisionShape();
+ if(currentShape == nullptr)
+ continue;
+
+ currentShape->getBoundingSphere(positionObject,radiusObject);
+ Vector3 positionObjectNonBT(positionObject.x(), positionObject.y(), positionObject.z());
+ Vector3 norm_r_CP = cP1ToCP2.crossProduct(centerCP1-positionObjectNonBT);
+
+ if(norm_r_CP.length() == 0){
+ Vector3 zufall;
+ do{
+ zufall=Vector3(rnd(),rnd(),rnd());//random
+ }while((zufall.crossProduct(cP1ToCP2)).length() == 0);
+ norm_r_CP=zufall.crossProduct(cP1ToCP2);
+ }
+ Vector3 VecToVCP = norm_r_CP.crossProduct(cP1ToCP2);
+ float distanzToCP1 = sqrt(powf(radiusObject,4)/(powf((centerCP1-positionObjectNonBT).length(), 2)-powf(radiusObject,2))+powf(radiusObject,2));
+ float distanzToCP2 = sqrt(powf(radiusObject,4)/(powf((racepoint2->getPosition()-positionObjectNonBT).length(), 2)-powf(radiusObject,2))+powf(radiusObject,2));
+ float distanz = std::max(distanzToCP1,distanzToCP2);
+ //float distanz = 0.0f; //TEMPORARY
+ Vector3 newCheckpointPositionPos = positionObjectNonBT+(distanz*VecToVCP)/VecToVCP.length();
+ Vector3 newCheckpointPositionNeg = positionObjectNonBT-(distanz*VecToVCP)/VecToVCP.length();
+ if((newCheckpointPositionPos - centerCP1).length() + (newCheckpointPositionPos - (centerCP1+cP1ToCP2)).length() < (newCheckpointPositionNeg - centerCP1).length() + (newCheckpointPositionNeg - (centerCP1+cP1ToCP2)).length() )
+ {
+ RaceCheckPoint* newVirtualCheckpoint = addVirtualCheckPoint(racepoint1,racepoint2->getCheckpointIndex(), newCheckpointPositionPos);
+ }
+ else
+ {
+ RaceCheckPoint* newVirtualCheckpoint = addVirtualCheckPoint(racepoint1,racepoint2->getCheckpointIndex(), newCheckpointPositionNeg);
+ }
+ return;
+ }
+ }
+
+ }*/
+
+ /*void SpaceRaceController::placeVirtualCheckpoints(RaceCheckPoint* racepoint1, RaceCheckPoint* racepoint2)
+ {
+ Vector3 point1 = racepoint1->getPosition();
+ Vector3 point2 = racepoint2->getPosition();
+ std::vector<StaticEntity*> problematicObjects;
+
+ ObjectList<StaticEntity> list;
+ for (ObjectList<StaticEntity>::iterator it = list.begin(); it!= list.end(); ++it)
+ {
+
+ if (dynamic_cast<RaceCheckPoint*>(*it) != nullptr)
+ {
+ continue;
+ } // does not work jet
+
+ problematicObjects.insert(problematicObjects.end(), *it);
+ //it->getScale3D();// vector fuer halbe wuerfellaenge
+ }
+
+ if(!directLinePossible(racepoint1, racepoint2, problematicObjects))
+ {
+ //orxout()<<"From "<<racepoint1->getCheckpointIndex()<<" to "<<racepoint2->getCheckpointIndex()<<"produces: "<< virtualCheckPointIndex<<endl;
+ computeVirtualCheckpoint(racepoint1, racepoint2, problematicObjects);
+ }
+
+ //
+ // do{
+ // zufall=Vector3(rnd(),rnd(),rnd());//random
+ // }while((zufall.crossProduct(objectmiddle-racepoint1->getPosition())).length()==0);
+ //
+ // Vector3 normalvec=zufall.crossProduct(objectmiddle-racepoint1->getPosition());
+ // // a'/b'=a/b => a' =b'*a/b
+ // float laengeNormalvec=(objectmiddle-racepoint1->getPosition()).length()/sqrt((objectmiddle-racepoint1->getPosition()).squaredLength()-radius*radius)*radius;
+ // addVirtualCheckPoint(racepoint1,racepoint2->getCheckpointIndex(), objectmiddle+normalvec/normalvec.length()*laengeNormalvec);
+
+ // Vector3 richtungen [6];
+ // richtungen[0]= Vector3(1,0,0);
+ // richtungen[1]= Vector3(-1,0,0);
+ // richtungen[2]= Vector3(0,1,0);
+ // richtungen[3]= Vector3(0,-1,0);
+ // richtungen[4]= Vector3(0,0,1);
+ // richtungen[5]= Vector3(0,0,-1);
+ //
+ // for (int i = 0; i< 6; i++)
+ // {
+ // const int STEPS=100;
+ // const float PHI=1.1;
+ // bool collision=false;
+ //
+ // for (int j =0; j<STEPS; j++)
+ // {
+ // Vector3 tempPosition=(point1 - (point2-point1+richtungen[i]*PHI)*(float)j/STEPS);
+ // for (std::vector<StaticEntity*>::iterator it = problematicObjects.begin(); it!=problematicObjects.end(); ++it)
+ // {
+ // btVector3 positionObject;
+ // btScalar radiusObject;
+ // if((*it)==nullptr)
+ // { orxout()<<"Problempoint 1.1"<<endl; continue;}
+ // //TODO: Probably it points on a wrong object
+ // for (int everyShape=0; (*it)->getAttachedCollisionShape(everyShape)!=nullptr; everyShape++)
+ // {
+ // if((*it)->getAttachedCollisionShape(everyShape)->getCollisionShape()==nullptr)
+ // { continue;}
+ //
+ // orxout()<<"Problempoint 2.1"<<endl;
+ // (*it)->getAttachedCollisionShape(everyShape)->getCollisionShape()->getBoundingSphere(positionObject,radiusObject);
+ // Vector3 positionObjectNonBT(positionObject.x(), positionObject.y(), positionObject.z());
+ // if (((tempPosition - positionObjectNonBT).length()<radiusObject) && (vergleicheQuader((tempPosition-positionObjectNonBT),(*it)->getScale3D())))
+ // {
+ // collision=true; break;
+ // }
+ // }
+ // if(collision) break;
+ // }
+ // if(collision)break;
+ // }
+ // if(collision) continue;
+ // // no collision => possible Way
+ // for (float j =0; j<STEPS; j++)
+ // {
+ // Vector3 possiblePosition=(point1 - (point2-point1+richtungen[i]*PHI)*j/STEPS);
+ // collision=false;
+ // for(int ij=0; ij<STEPS; j++)
+ // {
+ // Vector3 tempPosition=(possiblePosition - (point2-possiblePosition)*(float)ij/STEPS);
+ // for (std::vector<StaticEntity*>::iterator it = problematicObjects.begin(); it!=problematicObjects.end(); ++it)
+ // {
+ // btVector3 positionObject;
+ // btScalar radiusObject;
+ // if((*it)==nullptr)
+ // { orxout()<<"Problempoint 1"<<endl; continue;}
+ // for (int everyShape=0; (*it)->getAttachedCollisionShape(everyShape)!=nullptr; everyShape++)
+ // {
+ // if((*it)->getAttachedCollisionShape(everyShape)->getCollisionShape()==nullptr)
+ // { orxout()<<"Problempoint 2.2"<<endl; continue;}
+ // (*it)->getAttachedCollisionShape(everyShape)->getCollisionShape()->getBoundingSphere(positionObject,radiusObject);
+ // Vector3 positionObjectNonBT(positionObject.x(), positionObject.y(), positionObject.z());
+ // if (((tempPosition-positionObjectNonBT).length()<radiusObject) && (vergleicheQuader((tempPosition-positionObjectNonBT),(*it)->getScale3D())))
+ // {
+ // collision=true; break;
+ // }
+ // }
+ // if(collision) break;
+ // }
+ // if(collision)break;
+ // //addVirtualCheckPoint(racepoint1, racepoint2->getCheckpointIndex(), possiblePosition);
+ // return;
+ // }
+ //
+ // }
+ // }
+
+ }*/
}
More information about the Orxonox-commit
mailing list