Changeset 617

Timestamp:

Dec 18, 2007, 4:41:20 PM (16 years ago)

Author:

bknecht

Message:

implemented content of Flocking.h

Location:

code/branches/FICN/src/orxonox/objects

Files:

• NPC.cc (modified) (3 diffs)
• NPC.h (modified) (1 diff)

code/branches/FICN/src/orxonox/objects/NPC.cc

@@ -29 +29 @@
 #include "../core/Iterator.h"
 #include "../core/ObjectList.h"
-#include "../Flocking.h"
+//#include "../Flocking.h"
 
 namespace orxonox {
@@ -35 +35 @@
   NPC::NPC()
   {
+    movable_ = true;
   }
 
@@ -41 +42 @@
   }
 
-}
+  /**
+   * function to chance values of an element
+   */
+  void NPC::setValues(Vector3 location, Vector3 speed, Vector3 acceleration, bool movable) {
+    this->setAcceleration(acceleration);
+    this->setVelocity(speed);
+    this->translate(location);
+    movable_ = movable;
+  }
+
+  /**
+   * calculates the distance between the element and an other point given by temp
+   */
+  float NPC::getDistance(NPC* temp)
+  {
+    Vector3 distance = temp->getPosition() - this->getPosition();
+    return distance.length();
+  }
+
+  /**
+   * updates the data of an element
+   */
+  void NPC::tick(float dt)
+  {
+
+    // find out about this arrayOfElements
+    NPC* arrayOfElements[ANZELEMENTS];
+
+    //if element is movable, calculate acceleration
+    if (this->movable_ == true) calculateAcceleration(arrayOfElements);
+
+  }
+
+  /**
+   * calculates the new acceleration of an element
+   */
+  void NPC::calculateAcceleration(NPC** arrayOfElements)
+  {
+    //acceleration consisting of flocking-functions
+    this->setAcceleration(separation(arrayOfElements) + alignment(arrayOfElements) + cohesion(arrayOfElements));
+  }
+
+  /**
+   * separation-function (keep elements separated, avoid crashs)
+   */
+  Vector3 NPC::separation(NPC** arrayOfElements)
+  {
+    Vector3 steering = Vector3(0,0,0); //steeringvector
+    Vector3 inverseDistance = Vector3(0,0,0);  //vector pointing away from possible collisions
+    int numberOfNeighbour = 0;  //number of observed neighbours
+    float distance = 0;  // distance to the actual element
+    for(int i=0; i<ANZELEMENTS; i++) {  //go through all elements
+      NPC* actual = arrayOfElements[i];  //get the actual element
+      distance = getDistance(actual);  //get distance between this and actual
+      if ((distance > 0) && (distance < SEPERATIONDISTANCE)) {  //do only if actual is inside detectionradius
+        inverseDistance = Vector3(0,0,0);
+        inverseDistance = this->getPosition() - actual->getPosition();  //calculate the distancevector heading towards this
+        //adaptation of the inverseDistance to the distance
+        if ((distance < 200) && (distance >= 120)) {inverseDistance = 2*inverseDistance;}
+        if ((distance < 120) && (distance >= 80)) {inverseDistance = 5*inverseDistance;}
+        if ((distance < 80) && (distance >= 40)) {inverseDistance = 10*inverseDistance;}
+        if ((distance < 40) && (distance > 0)) {inverseDistance = 10*inverseDistance;}
+        steering = steering + inverseDistance;  //add up all significant steeringvectors
+        numberOfNeighbour++;  //counts the elements inside the detectionradius
+      }
+    }
+    if(numberOfNeighbour > 0) { steering = steering / (float)numberOfNeighbour; }  //devide the sum of steeringvectors by the number of elements -> separation steeringvector
+    return steering;
+  }
+
+  /**
+   * alignment-function (lead elements to the same heading)
+   */
+  Vector3 NPC::alignment(NPC** arrayOfElements)
+  {
+    Vector3 steering = Vector3(0,0,0); //steeringvector
+    int numberOfNeighbour = 0;  //number of observed neighbours
+    //float distance = 0;
+    //go through all elements
+    for(int i=0; i<ANZELEMENTS; i++) {  //just working with 3 elements at the moment
+      NPC* actual = arrayOfElements[i];  //get the actual element
+      float distance = getDistance(actual);  //get distance between this and actual
+      if ((distance > 0) && (distance < ALIGNMENTDISTANCE)) {  //check if actual element is inside detectionradius
+        steering = steering + actual->getVelocity();  //add up all speedvectors inside the detectionradius
+        numberOfNeighbour++;  //counts the elements inside the detectionradius
+      }
+    }
+    if(numberOfNeighbour > 0) { steering = steering / (float)numberOfNeighbour; }  //devide the sum of steeringvectors by the number of elements -> alignment steeringvector
+    return steering;
+  }
+
+  /**
+   * cohseion-function (keep elements close to each other)
+   */
+  Vector3 NPC::cohesion(NPC** arrayOfElements)
+  {
+    Vector3 steering = Vector3(0,0,0); //steeringvector
+    int numberOfNeighbour = 0;  //number of observed neighbours
+    //float distance = 0;
+    //go through all elements
+    for(int i=0; i<ANZELEMENTS; i++) {  //just working with 3 elements at the moment
+      NPC* actual = arrayOfElements[i];  //get the actual element
+      float distance = getDistance(actual);  //get distance between this and actual
+      if ((distance > 0) && (distance < COHESIONDISTANCE)) {  //check if actual element is inside detectionradius
+        steering = steering + actual->getPosition();  //add up all locations of elements inside the detectionradius
+        numberOfNeighbour++;  //counts the elements inside the detectionradius
+      }
+    }
+    if(numberOfNeighbour > 0) {
+      steering = steering  / (float)numberOfNeighbour;  //devide the sum steeringvector by the number of elements -> cohesion steeringvector
+      steering = steering - this->getPosition();  //transform the vector for the ship
+    }
+    return steering;
+  }
+
+} // end of class NPC

code/branches/FICN/src/orxonox/objects/NPC.h

@@ -10 +10 @@
 // includes
 #include "WorldEntity.h"
+#include "Model.h"
 
 namespace orxonox {
 
-  class NPC : public WorldEntity
+  class NPC : public Model
   {
-    NPC();
-    virtual ~NPC();
+    public:
+
+      NPC();
+      virtual ~NPC();
+      void tick(float dt);
+      void setValues(Vector3 location, Vector3 speed, Vector3 acceleration, bool movable);
+
+    private:
+      float getDistance(NPC* temp);
+      void calculateAcceleration(NPC** arrayOfElements);
+      Vector3 separation(NPC** arrayOfElements);
+      Vector3 alignment(NPC** arrayOfElements);
+      Vector3 cohesion(NPC** arrayOfElements);
+
+
+    private:
+      bool movable_;  // movability of the element, (false) gives the possiblity that an object can`t be moved by flocking but still gets into the calculation
+
+      // those values should maybe be controlled by a higher power and should maybe be parameters that can be changed
+      static int const SEPERATIONDISTANCE = 300;  //detectionradius of seperation
+      static int const ALIGNMENTDISTANCE = 300;  //detectionradius of alignment
+      static int const COHESIONDISTANCE = 5000;  //detectionradius of cohesion
+      static int const ANZELEMENTS = 9;  //number of elements
   };