Changeset 2885 for code/trunk

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

Files:

• controllers/PongAI.cc (modified) (11 diffs)
• controllers/PongAI.h (modified) (2 diffs)
• gametypes/Pong.cc (modified) (2 diffs)
• worldentities/PongBall.cc (modified) (3 diffs)
• worldentities/PongBall.h (modified) (1 diff)

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_;
     };
 }

code/trunk/src/orxonox/objects/gametypes/Pong.cc

@@ -53 +53 @@
         this->bat_[0] = 0;
         this->bat_[1] = 0;
-
-        this->bForceSpawn_ = true;
 
         this->starttimer_.setTimer(1.0, false, this, createExecutor(createFunctor(&Pong::startBall)));
@@ -111 +109 @@
         this->starttimer_.startTimer();
 
+
+        bool temp = this->bForceSpawn_;
+        this->bForceSpawn_ = true;
+
         Deathmatch::start();
+
+        this->bForceSpawn_ = temp;
     }
 

code/trunk/src/orxonox/objects/worldentities/PongBall.cc

@@ -37 +37 @@
 {
     CreateFactory(PongBall);
+
+    const float PongBall::MAX_REL_Z_VELOCITY = 1.5;
 
     PongBall::PongBall(BaseObject* creator) : MovableEntity(creator)
@@ -79 +81 @@
                             position.x = this->fieldWidth_ / 2;
                             velocity.x = -velocity.x;
-                            velocity.z = distance * distance * sgn(distance) * 1.5 * this->speed_;
+                            velocity.z = distance * distance * sgn(distance) * PongBall::MAX_REL_Z_VELOCITY * this->speed_;
                         }
                         else if (position.x > this->fieldWidth_ / 2 * (1 + this->relMercyOffset_))
@@ -97 +99 @@
                             position.x = -this->fieldWidth_ / 2;
                             velocity.x = -velocity.x;
-                            velocity.z = distance * distance * sgn(distance) * 1.5 * this->speed_;
+                            velocity.z = distance * distance * sgn(distance) * PongBall::MAX_REL_Z_VELOCITY * this->speed_;
                         }
                         else if (position.x < -this->fieldWidth_ / 2 * (1 + this->relMercyOffset_))

code/trunk/src/orxonox/objects/worldentities/PongBall.h

@@ -63 +63 @@
                 { this->bat_ = bats; }
 
+            static const float MAX_REL_Z_VELOCITY;
+
         private:
             float fieldWidth_;