Changeset 7673 for code/trunk/src/modules/objects/ForceField.cc

Timestamp:

Nov 25, 2010, 11:24:50 PM (14 years ago)

Author:

dafrick

Message:

Documenting and extending ForceField.
A little cleaning up in The Time Machine level.
Adding a Bond villain…

File:

• code/trunk/src/modules/objects/ForceField.cc (modified) (4 diffs)

code/trunk/src/modules/objects/ForceField.cc

@@ -27 +27 @@
  */
 
+/**
+@file ForceField.cc
+@brief Implementation of the ForceField class.
+*/
+
 #include "ForceField.h"
 
@@ -36 +41 @@
 {
     CreateFactory(ForceField);
+    
+    /*static*/ const std::string modeStringNormal_s = "tube";
+    /*static*/ const std::string modeStringSphere_s = "sphere";
 
     ForceField::ForceField(BaseObject* creator) : StaticEntity(creator)
@@ -43 +51 @@
         //Standard Values
         this->setDirection(Vector3::ZERO);
-        velocity_ = 100;
-        diameter_ = 500;
-        length_ = 5000;
+        this->velocity_ = 100;
+        this->diameter_ = 500;
+        this->length_ = 5000;
+        this->mode_ = ForceFieldMode::tube;
     }
 
-    ForceField::~ForceField() {}
+    ForceField::~ForceField()
+    {
+    }
 
     void ForceField::XMLPort(Element& xmlelement, XMLPort::Mode mode)
@@ -58 +69 @@
         XMLPortParam(ForceField, "diameter", setDiameter, getDiameter, xmlelement, mode).defaultValues(500);
         XMLPortParam(ForceField, "length"  , setLength  , getLength  , xmlelement, mode).defaultValues(2000);
+        XMLPortParam(ForceField, "mode", setMode, getMode, xmlelement, mode);
     }
 
     void ForceField::tick(float dt)
     {
+        // Iterate over all objects that could possibly be affected by the ForceField.
         for (ObjectList<MobileEntity>::iterator it = ObjectList<MobileEntity>::begin(); it != ObjectList<MobileEntity>::end(); ++it)
         {
-            //calculate from
-            Vector3 directionVec = this->getOrientation() * WorldEntity::FRONT;
-            directionVec.normalise();
+            if(this->mode_ == ForceFieldMode::tube)
+            {
+                // The direction of the orientation of the force field.
+                Vector3 direction = this->getOrientation() * WorldEntity::FRONT;
+                direction.normalise();
 
-            Vector3 distanceVec = it->getWorldPosition() - (this->getWorldPosition() + (this->length_ / 2 * directionVec));
+                // Vector from the center of the force field to the object its acting on.
+                // TODO: This could probably be simplified.
+                Vector3 distanceVector = it->getWorldPosition() - (this->getWorldPosition() + (this->halfLength_ * direction));
+                
+                // The object is outside of the length of the ForceField.
+                if(distanceVector.length() > this->halfLength_)
+                    return;
 
-            //distance from centervector of the field (
-            float distFromCenterVec = ((it->getWorldPosition() - this->getWorldPosition()).crossProduct(directionVec)).length();
+                // The distance of the object form the orientation vector. (Or rather the smallest distance from the orientation vector)
+                float distanceFromDirectionVector = ((it->getWorldPosition() - this->getWorldPosition()).crossProduct(direction)).length();
+                
+                // If the object in a tube of radius diameter/2 around the direction of orientation.
+                if(distanceFromDirectionVector >= this->radius_)
+                    return;
 
-            if (distanceVec.length() < this->length_ / 2 && distFromCenterVec < diameter_ / 2)
+                // Apply a force to the object in the direction of the orientation.
+                // The force is highest when the object is directly on the direction vector, with a linear decrease, finally reaching zero, when distanceFromDirectionVector = radius.
+                it->applyCentralForce(((this->radius_ - distanceFromDirectionVector)/(this->radius_)) * this->velocity_ * direction);
+            }
+            else if(this->mode_ == ForceFieldMode::sphere)
             {
-                //normalize distance from center
-                it->applyCentralForce(((diameter_ / 2 - distFromCenterVec) / (diameter_ / 2)) * directionVec * velocity_);
+                Vector3 distanceVector = it->getWorldPosition() - this->getWorldPosition();
+                float distance = distanceVector.length();
+                if (distance < this->radius_)
+                {
+                    distanceVector.normalise();
+                    it->applyCentralForce((this->radius_ - distance)/this->radius_ * this->velocity_ * distanceVector);
+                }
             }
+        }
+    }
+    
+    void ForceField::setMode(const std::string& mode)
+    {
+        if(mode == ForceField::modeStringTube_s)
+            this->mode_ = ForceFieldMode::tube;
+        else if(mode == ForceField::modeStringSphere_s)
+            this->mode_ = ForceFieldMode::sphere;
+        else
+        {
+            COUT(2) << "Wrong mode '" << mode << "' in ForceField. Setting to 'tube'." << std::endl;
+            this->mode_ = ForceFieldMode::tube;
+        }
+    }
+    
+    inline const std::string& ForceField::getMode(void)
+    {
+        switch(this->mode_)
+        {
+            case ForceFieldMode::tube:
+                return ForceField::modeStringTube_s;
+            case ForceFieldMode::sphere:
+                return ForceField::modeStringSphere_s;
+            default:
+                return ForceField::modeStringTube_s;
         }
     }