Changeset 1566 for code/trunk

Timestamp:

Jun 8, 2008, 5:04:18 PM (17 years ago)

Author:

landauf

Message:

• added a prediction-crosshair to the navigation focus
• fixed a bug in SpaceShipAI's target movement prediction - bots are more accurate now

Location:

code/trunk/src

Files:

• orxonox/hud/Navigation.cc (modified) (6 diffs)
• orxonox/hud/RadarObject.cc (modified) (1 diff)
• orxonox/hud/RadarObject.h (modified) (1 diff)
• orxonox/objects/SpaceShipAI.cc (modified) (2 diffs)
• util/Math.cc (modified) (1 diff)
• util/Math.h (modified) (1 diff)

code/trunk/src/orxonox/hud/Navigation.cc

@@ -36 +36 @@
 // TODO: remove the SpaceShip and CameraHandler dependencies
 #include "objects/SpaceShip.h"
+#include "objects/Projectile.h"
 #include "objects/CameraHandler.h"
 #include "RadarObject.h"
@@ -87 +88 @@
         navMarker_->hide();
         aimMarker_->hide();
+        aimMarker_->setMaterialName("Orxonox/NavCrosshair");
+        aimMarker_->setDimensions(20, 20);
+        aimMarker_->setUV(0.0, 0.0, 1.0, 1.0);
         container_->addChild(navMarker_);
         container_->addChild(aimMarker_);
@@ -106 +110 @@
         navText_->setCaption(Ogre::StringConverter::toString(dist));
 
-        Vector3 pos = focus_->getPosition();
         Ogre::Camera* navCam = SpaceShip::getLocalShip()->getCamera()->cam_;
         // transform to screen coordinates
-        pos = navCam->getProjectionMatrix() * navCam->getViewMatrix() * pos;
+        Vector3 pos = navCam->getProjectionMatrix() * navCam->getViewMatrix() * focus_->getPosition();
+        Vector3 aimpos = navCam->getProjectionMatrix() * navCam->getViewMatrix() * getPredictedPosition(SpaceShip::getLocalShip()->getPosition(), Projectile::getSpeed(), focus_->getPosition(), focus_->getOrientedVelocity());
 
         float xPosRel = 0.5*pos.x+0.5;
         float yPosRel = 1-(0.5*pos.y+0.5);
+        float xAimPosRel = 0.5*aimpos.x+0.5;
+        float yAimPosRel = 1-(0.5*aimpos.y+0.5);
         int xPos = (int) (xPosRel*windowW);
         int yPos = (int) (yPosRel*windowH);
+        int xAimPos = (int) (xAimPosRel*windowW);
+        int yAimPos = (int) (yAimPosRel*windowH);
         int xFromCenter = xPos-windowW/2;
         int yFromCenter = yPos-windowH/2;
@@ -133 +141 @@
             navMarker_->setMaterialName("Orxonox/NavArrows");
             navMarker_->setDimensions(16,16);
+            aimMarker_->hide();
             float phiUpperCorner = atan((float)(windowW)/(float)(windowH));
             // from the angle we find out on which edge to draw the marker
@@ -210 +219 @@
             // object is in view
             navMarker_->setMaterialName("Orxonox/NavTDC");
-            navMarker_->setDimensions(24,24);
+            navMarker_->setDimensions(35, 35);
             navMarker_->setUV(0.0, 0.0, 1.0, 1.0);
             navMarker_->setPosition(xPos-navMarker_->getWidth()/2, yPos-navMarker_->getHeight()/2);
+
+            aimMarker_->show();
+            aimMarker_->setPosition(xAimPos-aimMarker_->getWidth()/2, yAimPos-aimMarker_->getHeight()/2);
+
             navText_->setPosition(xPos+navMarker_->getWidth()/2, yPos+navMarker_->getHeight()/2);
         }
@@ -259 +272 @@
         if(focus_ == NULL){
             navMarker_->hide();
+            aimMarker_->hide();
             navText_->hide();
         }

code/trunk/src/orxonox/hud/RadarObject.cc

@@ -120 +120 @@
     }
 
-    const Vector3& RadarObject::getVelocity() const
+    Vector3 RadarObject::getOrientedVelocity() const
     {
-        return this->object_->getVelocity();
+        return this->object_->getOrientation() * this->object_->getVelocity();
     }
 }

code/trunk/src/orxonox/hud/RadarObject.h

@@ -54 +54 @@
 
         const Vector3& getPosition() const;
-        const Vector3& getVelocity() const;
+        Vector3 getOrientedVelocity() const;
 
         inline WorldEntity* getObject() const

code/trunk/src/orxonox/objects/SpaceShipAI.cc

@@ -238 +238 @@
         this->setMovePitch(0.8 * sgn(coord.y));
 
-        if ((this->targetPosition_ - this->getPosition()).length() > 300)
+        if ((this->targetPosition_ - this->getPosition()).length() > 500)
             this->setMoveLongitudinal(0.8);
 
@@ -287 +287 @@
             return;
 
-        Vector3 enemymovement = this->target_->getVelocity();
-        Vector3 distance_normalised = this->target_->getPosition() - this->getPosition();
-        distance_normalised.normalise();
-
-        float scalarprod = enemymovement.dotProduct(distance_normalised);
-        float aimoffset = scalarprod*scalarprod + Projectile::getSpeed() * Projectile::getSpeed() - this->target_->getVelocity().squaredLength();
-
-        if (aimoffset < 0)
-        {
-            this->bHasTargetPosition_ = false;
-            return;
-        }
-        aimoffset = -scalarprod + sqrt(aimoffset);
-        this->targetPosition_ = this->getPosition() + enemymovement + distance_normalised * aimoffset;
-        this->bHasTargetPosition_ = true;
+        this->targetPosition_ = getPredictedPosition(this->getPosition(), Projectile::getSpeed(), this->target_->getPosition(), this->target_->getOrientation() * this->target_->getVelocity());
+        this->bHasTargetPosition_ = (this->targetPosition_ != Vector3::ZERO);
     }
 

code/trunk/src/util/Math.cc

@@ -106 +106 @@
         return orxonox::Vector2(-sin(angle) * radius, cos(angle) * radius);
 }
+
+orxonox::Vector3 getPredictedPosition(const orxonox::Vector3& myposition, float projectilespeed, const orxonox::Vector3& targetposition, const orxonox::Vector3& targetvelocity)
+{
+    float squaredProjectilespeed = projectilespeed * projectilespeed;
+    orxonox::Vector3 distance = targetposition - myposition;
+    float a = distance.squaredLength();
+    float b = 2 * (distance.x + distance.y + distance.z) * (targetvelocity.x + targetvelocity.y + targetvelocity.z);
+    float c = targetvelocity.squaredLength();
+
+    float temp = 4*squaredProjectilespeed*c + a*a - 4*b*c;
+    if (temp < 0)
+        return orxonox::Vector3::ZERO;
+
+    temp = sqrt(temp);
+    float time = (temp + a) / (2 * (squaredProjectilespeed - b));
+    return (targetposition + targetvelocity * time);
+}

code/trunk/src/util/Math.h

@@ -62 +62 @@
 _UtilExport orxonox::Vector2 get2DViewdirection(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition);
 _UtilExport orxonox::Vector2 get2DViewcoordinates(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition);
+_UtilExport orxonox::Vector3 getPredictedPosition(const orxonox::Vector3& myposition, float projectilespeed, const orxonox::Vector3& targetposition, const orxonox::Vector3& targetvelocity);
 
 template <typename T>