Changeset 2885 for code/trunk/src/orxonox/objects/controllers

Timestamp:

Apr 1, 2009, 12:37:16 AM (16 years ago)

Author:

landauf

Message:

Extended PongAI:

• Random prediction errors depend on the vertical ball-speed
• Fixed a bug: Position correction was also affected by the reaction delay. Now it works instantly.
• Added oscillation avoidance system (the already implemented hysteresis avoidance system failed at low framerates)

Additionally fixed auto-respawn in Pong Gametype.

Location:

code/trunk/src/orxonox/objects/controllers

Files:

• PongAI.cc (modified) (11 diffs)
• PongAI.h (modified) (2 diffs)

code/trunk/src/orxonox/objects/controllers/PongAI.cc

@@ -53 +53 @@
         this->strength_ = 0.5;
         this->movement_ = 0;
+        this->oldMove_ = 0;
+        this->bOscillationAvoidanceActive_ = false;
 
         this->setConfigValues();
@@ -79 +81 @@
 
         char move = 0;
+        bool delay = false;
 
         // Check in which direction the ball is flying
@@ -86 +89 @@
             this->ballDirection_.x = -1;
             this->ballDirection_.y = 0;
+            this->bOscillationAvoidanceActive_ = false;
 
             // Move to the middle
@@ -98 +102 @@
             this->ballDirection_.x = 0;
             this->ballDirection_.y = 0;
+            this->bOscillationAvoidanceActive_ = false;
         }
         else
@@ -112 +117 @@
                 this->calculateRandomOffset();
                 this->calculateBallEndPosition();
+                delay = true;
+                this->bOscillationAvoidanceActive_ = false;
             }
 
@@ -120 +127 @@
 
                 this->calculateBallEndPosition();
+                delay = true;
+                this->bOscillationAvoidanceActive_ = false;
             }
 
             // Move to the predicted end position with an additional offset (to hit the ball with the side of the bat)
-            float desiredZValue = this->ballEndPosition_ + this->randomOffset_;
-
-            if (mypos.z > desiredZValue + hysteresisOffset * (this->randomOffset_ < 0))
-                move = 1;
-            else if (mypos.z < desiredZValue - hysteresisOffset * (this->randomOffset_ > 0))
-                move = -1;
-        }
-
-        this->move(move);
+            if (!this->bOscillationAvoidanceActive_)
+            {
+                float desiredZValue = this->ballEndPosition_ + this->randomOffset_;
+
+                if (mypos.z > desiredZValue + hysteresisOffset * (this->randomOffset_ < 0))
+                    move = 1;
+                else if (mypos.z < desiredZValue - hysteresisOffset * (this->randomOffset_ > 0))
+                    move = -1;
+            }
+
+            if (move != 0 && this->oldMove_ != 0 && move != this->oldMove_ && !delay)
+            {
+                // We had to correct our position because we moved too far
+                // (and delay ist false, so we're not in the wrong place because of a new end-position prediction)
+                if (fabs(mypos.z - this->ballEndPosition_) < 0.5 * this->ball_->getBatLength() * this->ball_->getFieldDimension().y)
+                {
+                    // We're not at the right position, but we still hit the ball, so just stay there to avoid oscillation
+                    move = 0;
+                    this->bOscillationAvoidanceActive_ = true;
+                }
+            }
+        }
+
+        this->oldMove_ = move;
+        this->move(move, delay);
         this->getControllableEntity()->moveFrontBack(this->movement_);
     }
@@ -168 +193 @@
         for (float limit = 0.35; limit < this->strength_ || this->strength_ > 0.99; limit += 0.4)
         {
-            // Bounce from the upper bound
+            // Calculate a random prediction error, based on the vertical speed of the ball and the strength of the AI
+            float randomError = rnd(-1, 1) * dimension.y * (velocity.z / velocity.x / PongBall::MAX_REL_Z_VELOCITY) * (1 - this->strength_);
+
+            // Bounce from the lower bound
             if (this->ballEndPosition_ > dimension.y / 2)
             {
                 // Mirror the predicted position at the upper bound and add some random error
-                this->ballEndPosition_ = dimension.y - this->ballEndPosition_ + (rnd(-1, 1) * dimension.y * (1 - this->strength_));
+                this->ballEndPosition_ = dimension.y - this->ballEndPosition_ + randomError;
                 continue;
             }
@@ -179 +207 @@
             {
                 // Mirror the predicted position at the lower bound and add some random error
-                this->ballEndPosition_ = -dimension.y - this->ballEndPosition_ + (rnd(-1, 1) * dimension.y * (1 - this->strength_));
+                this->ballEndPosition_ = -dimension.y - this->ballEndPosition_ + randomError;
                 continue;
             }
@@ -187 +215 @@
     }
 
-    void PongAI::move(char direction)
+    void PongAI::move(char direction, bool bUseDelay)
     {
         // The current direction is either what we're doing right now (movement_) or what is last in the queue
@@ -198 +226 @@
             return;
 
-        // Calculate delay, but only to change direction or start moving (stop works without delay)
-        if (direction != 0)
-        {
+        if (bUseDelay)
+        {
+            // Calculate delay
             float delay = MAX_REACTION_TIME * (1 - this->strength_);
 
@@ -209 +237 @@
         else
         {
-            this->movement_ = 0;
+            this->movement_ = direction;
         }
     }

code/trunk/src/orxonox/objects/controllers/PongAI.h

@@ -56 +56 @@
             void calculateRandomOffset();
             void calculateBallEndPosition();
-            void move(char direction);
+            void move(char direction, bool bUseDelay);
             void delayedMove();
 
@@ -68 +68 @@
             std::list<std::pair<Timer<PongAI>*, char> > reactionTimers_;
             char movement_;
+            char oldMove_;
+            bool bOscillationAvoidanceActive_;
     };
 }