Changeset 10018 for code/branches/turretFS14/src/modules

Timestamp:

Apr 3, 2014, 2:57:05 PM (11 years ago)

Author:

muemart

Message:

Turret: Limit turret's rotation (not really precise though) & implement xml stuff

Location:

code/branches/turretFS14/src/modules/objects

Files:

• Turret.cc (modified) (2 diffs)
• Turret.h (modified) (2 diffs)
• controllers/TurretController.cc (modified) (2 diffs)
• controllers/TurretController.h (modified) (1 diff)

code/branches/turretFS14/src/modules/objects/Turret.cc

@@ -45 +45 @@
     {
         RegisterObject(Turret);
-        this->controller_ = new WaypointPatrolController(this->getContext());
-        gotOrient_ = false;
+        this->startOrientInv_ = Quaternion::IDENTITY;
+        this->maxPitch_ = 0;
+        this->maxYaw_ = 0;
+        this->gotOrient_ = false;
     }
 
@@ -60 +62 @@
     void Turret::rotatePitch(const Vector2& value)
     {
-        Radian currentPitch = this->getOrientation().getPitch();
-        Radian startPitch = startOrient_.getPitch();
-        Radian limit = Radian((Degree)45);
-        Radian upperBoundary = startPitch+limit;
-        if(upperBoundary > Radian(Degree(360)))
+        if (this->maxPitch_ == 0)
         {
-            upperBoundary -= Radian(Degree(360));
+            return;
         }
-        Radian lowerBoundary = startPitch-limit;
-        if(lowerBoundary < Radian(Degree(0)))
+        if (this->maxPitch_ >= 180) //no need to check, if the limit too big
         {
-            lowerBoundary += Radian(Degree(360));
+           SpaceShip::rotatePitch(value);
+           return;
         }
-        //orxout() << "Pitch:\t" << currentPitch << "\t" << startPitch << endl;
-        
-        if(currentPitch > upperBoundary && value.x > 0 ||
-           currentPitch < lowerBoundary && value.x < 0)
+
+        Quaternion drot = startOrientInv_ * this->getOrientation();
+
+        Ogre::Real val = boundBetween(drot.getPitch(false).valueDegrees(), -180, 180);
+        Ogre::Real offset = boundBetween(Degree(value.x).valueDegrees(), -180, 180);
+        Ogre::Real lowerBound = offset - this->maxPitch_;
+        Ogre::Real upperBound = offset + this->maxPitch_;
+        if (lowerBound < -180) //Avoid wrapping around of the boundaries
         {
-            //return;
+            lowerBound += this->maxPitch_;
+            upperBound += this->maxPitch_;
+            val = boundBetween(val + this->maxPitch_, -180, 180); //val might wrap around here
         }
-        
-        SpaceShip::rotatePitch(value);
+        else if (upperBound >= 180) //Avoid wrapping around of the boundaries (the other side)
+        {
+            lowerBound -= this->maxPitch_;
+            upperBound -= this->maxPitch_;
+            val = boundBetween(val-this->maxPitch_, -180, 180); //val might wrap around here
+        }
+        if ((val >= lowerBound || value.x > 0) && (val <= upperBound || value.x < 0)) 
+        {
+            SpaceShip::rotatePitch(value);
+        }
+        return;
     }
 
     void Turret::rotateYaw(const Vector2& value)
     {
+        if (this->maxPitch_ == 0)
+        {
+            return;
+        }
+        if (this->maxPitch_ >= 180) //no need to check, if the limit too big
+        {
+           SpaceShip::rotateYaw(value);
+           return;
+        }
 
-        Radian currentYaw = this->getOrientation().getYaw();
-        Radian startYaw = startOrient_.getYaw();
-        Radian limit = Radian(Degree(45));
-        Radian upperBoundary = startYaw + limit;
-        Radian lowerBoundary = startYaw - limit;
-        /*if(upperBoundary >= Radian(Degree(180)));
+        Quaternion drot = startOrientInv_ * this->getOrientation();
+
+        Ogre::Real val = boundBetween(drot.getYaw(false).valueDegrees(), -180, 180);
+        Ogre::Real offset = boundBetween(Degree(value.x).valueDegrees(), -180, 180);
+        Ogre::Real lowerBound = offset - this->maxPitch_;
+        Ogre::Real upperBound = offset + this->maxPitch_;
+        if (lowerBound < -180) //Avoid wrapping around of the boundaries
         {
-            upperBoundary -= Radian(Degree(180));
-            lowerBoundary -= Radian(Degree(180));
-            currentYaw -= Radian(Degree(180));
+            lowerBound += this->maxPitch_;
+            upperBound += this->maxPitch_;
+            val = boundBetween(val + this->maxPitch_, -180, 180); //val might wrap around here
         }
-        if(lowerBoundary <= Radian(Degree(-180)))
+        else if (upperBound >= 180) //Avoid wrapping around of the boundaries (the other side)
         {
-            lowerBoundary += Radian(Degree(180));
-            upperBoundary += Radian(Degree(180));
-            currentYaw += Radian(Degree(180));
-        }*/
-        //orxout() << "Yaw:\t" << (Degree)currentYaw << "\t" << (Degree)upperBoundary << "\t" << (Degree)lowerBoundary << endl;
-        //if((currentYaw > upperBoundary && value.x > 0) ||
-        //   (currentYaw < lowerBoundary && value.x < 0))
-        if((currentYaw < Radian(1) && value.x < 0) || (currentYaw > Radian(3) && value.x>0))
+            lowerBound -= this->maxPitch_;
+            upperBound -= this->maxPitch_;
+            val = boundBetween(val-this->maxPitch_, -180, 180); //val might wrap around here
+        }
+        if ((val >= lowerBound || value.x > 0) && (val <= upperBound || value.x < 0)) 
         {
-            //return;
+            SpaceShip::rotateYaw(value);
         }
-        SpaceShip::rotateYaw(value);
+        return;
     }
 
     void Turret::rotateRoll(const Vector2& value)
     {
-        SpaceShip::rotateRoll(value);
-    }
-
-    void Turret::setAlertnessRadius(float value)
-    {
-        this->controller_->setAlertnessRadius(value);
-    }
-    float Turret::getAlertnessRadius()
-    {
-        return this->controller_->getAlertnessRadius();
+        return; //Standard turrets don't roll
     }
 
     void Turret::XMLPort(Element& xmlelement, XMLPort::Mode mode)
     {
+        XMLPortParam(Turret, "maxPitch", setMaxPitch, getMaxPitch, xmlelement, mode);
+        XMLPortParam(Turret, "maxYaw", setMaxYaw, getMaxYaw, xmlelement, mode);
         SUPER(Turret, XMLPort, xmlelement, mode);
-        XMLPortParam(Turret, "alertnessRadius", setAlertnessRadius, getAlertnessRadius, xmlelement, mode).defaultValues("400");
     }
 
     void Turret::tick(float dt)
     {
-        orxout() << "Pitch: " << this->getOrientation().getPitch() << "\tYaw: " << this->getOrientation().getYaw() << "\tRoll: " << this->getOrientation().getRoll() << endl;
         if(!gotOrient_)
         {
-            startOrient_ = this->getOrientation();
+            startOrientInv_ = this->getOrientation().Inverse();
             gotOrient_ = true;
         }
+        Quaternion drot = startOrientInv_ * this->getOrientation();
+        orxout() << "Pitch: " << drot.getPitch(false).valueDegrees() << "\tYaw: " << drot.getYaw(false).valueDegrees() << "\tRoll: " << drot.getRoll(false).valueDegrees() << endl;
         SUPER(Turret, tick, dt);
     }
 
+
+    Ogre::Real Turret::boundBetween(Ogre::Real val, Ogre::Real lowerBound, Ogre::Real upperBound)
+    {
+        if (lowerBound > upperBound){ std::swap(lowerBound, upperBound); }
+        val -= lowerBound; //adjust to 0
+        Ogre::Real rangeSize = upperBound - lowerBound;
+        if (rangeSize == 0){ return upperBound; } //avoid dividing by 0
+        return val - (rangeSize * std::floor(val / rangeSize)) + lowerBound;
+    }
+
 }

code/branches/turretFS14/src/modules/objects/Turret.h

@@ -40 +40 @@
 
 #include "worldentities/pawns/SpaceShip.h"
+#include "controllers/TurretController.h"
 
 namespace orxonox
@@ -53 +54 @@
             virtual void rotateRoll(const Vector2& value);
 
-            void setAlertnessRadius(float value);
-            float getAlertnessRadius();
-
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
             virtual void tick(float dt);
 
+            inline void setMaxPitch(Ogre::Real pitch)
+                {this->maxPitch_ = pitch;}
 
-        protected:
-            WaypointPatrolController* controller_;
+            inline Ogre::Real getMaxPitch()
+                {return this->maxPitch_;}
+
+            inline void setMaxYaw(Ogre::Real yaw)
+                {this->maxYaw_ = yaw;}
+
+            inline Ogre::Real getMaxYaw()
+                {return this->maxYaw_;}
+
         private:
             bool gotOrient_;
-            Quaternion startOrient_;
+            Ogre::Real maxPitch_;
+            Ogre::Real maxYaw_;
+            Quaternion startOrientInv_;
+
+            Ogre::Real boundBetween(float val, float lowerBound, float upperBound);
     };
 }

code/branches/turretFS14/src/modules/objects/controllers/TurretController.cc

@@ -36 +36 @@
         {
                 RegisterObject(TurretController);
+                counter = 0;
+                flag = false;
         }
 
@@ -45 +47 @@
         void TurretController::tick(float dt)
         {
-                this->getControllableEntity()->rotateYaw(10*dt);
+                counter += dt;
+                if(counter >= 10)
+                {
+                        counter = 0;
+                        flag = !flag;
+                        orxout() << "Direction change" << endl;
+                }
+                if(flag)
+                {
+                        this->getControllableEntity()->rotatePitch(10*dt);
+                        //this->getControllableEntity()->rotateYaw(10*dt);
+                }
+                else
+                {
+                        this->getControllableEntity()->rotatePitch(-10*dt);
+                        //this->getControllableEntity()->rotateYaw(-10*dt);
+                }
         }
  }

code/branches/turretFS14/src/modules/objects/controllers/TurretController.h

@@ -42 +42 @@
 
                         virtual void tick(float dt);
+
+                private:
+                        float counter;
+                        bool flag;
         };
  }