Allow auto-rescue for ArenaAI if off road for some times

src/karts/controller/arena_ai.cpp

@@ -25,9 +25,9 @@
 #include "karts/abstract_kart.hpp"
 #include "karts/controller/ai_properties.hpp"
 #include "karts/kart_properties.hpp"
+#include "karts/rescue_animation.hpp"
 #include "tracks/arena_graph.hpp"
 #include "tracks/arena_node.hpp"
-#include "utils/log.hpp"
 
 ArenaAI::ArenaAI(AbstractKart *kart)
        : AIBaseController(kart)
@@ -58,6 +58,7 @@ void ArenaAI::reset()
     m_target_point_lc = Vec3(0, 0, 0);
     m_time_since_last_shot = 0.0f;
     m_time_since_driving = 0.0f;
+    m_time_since_off_road = 0.0f;
     m_time_since_reversing = 0.0f;
     m_time_since_uturn = 0.0f;
     m_turn_radius = 0.0f;
@@ -90,6 +91,24 @@ void ArenaAI::update(float dt)
         return;
     }
 
+    if (!isKartOnRoad() && !m_kart->getKartAnimation())
+    {
+        m_time_since_off_road += dt;
+    }
+    else if (m_time_since_off_road != 0.0f)
+    {
+        m_time_since_off_road = 0.0f;
+    }
+
+    // If the kart needs to be rescued, do it now (and nothing else)
+    if (m_time_since_off_road > 5.0f && !m_kart->getKartAnimation())
+    {
+        m_time_since_off_road = 0.0f;
+        new RescueAnimation(m_kart);
+        AIBaseController::update(dt);
+        return;
+    }
+
     if (isWaiting())
     {
         AIBaseController::update(dt);

src/karts/controller/arena_ai.hpp

@@ -99,6 +99,9 @@ private:
     /** This is a timer that counts down when the kart is doing u-turn. */
     float m_time_since_uturn;
 
+    /** This is a timer that counts when the kart start going off road. */
+    float m_time_since_off_road;
+
     float m_turn_radius;
     float m_turn_angle;
     float m_steering_angle;
@@ -122,21 +125,23 @@ private:
     void         updateBadItemLocation();
     void         updateTurnRadius(const Vec3& p1, const Vec3& p2,
                                   const Vec3& p3);
-    virtual int  getCurrentNode() const = 0;
-    virtual bool isWaiting() const = 0;
-    virtual void resetAfterStop() {};
-    virtual void findClosestKart(bool use_difficulty) = 0;
-    virtual void findTarget() = 0;
+    virtual bool  canSkid(float steer_fraction) OVERRIDE
+                                     { return m_mini_skid; }
+    virtual void  findClosestKart(bool use_difficulty) = 0;
+    virtual void  findTarget() = 0;
+    virtual bool  forceBraking() { return m_avoiding_item; }
+    virtual int   getCurrentNode() const = 0;
     virtual float getKartDistance(int to_id) const = 0;
-    virtual bool forceBraking() { return m_avoiding_item; }
-    virtual bool ignorePathFinding() { return false; }
-    virtual bool canSkid(float steer_fraction) { return m_mini_skid; }
+    virtual bool  ignorePathFinding() { return false; }
+    virtual bool  isWaiting() const = 0;
+    virtual bool  isKartOnRoad() const = 0;
+    virtual void  resetAfterStop() {};
 public:
                  ArenaAI(AbstractKart *kart);
     virtual     ~ArenaAI() {};
-    virtual void update      (float delta);
-    virtual void reset       ();
-    virtual void newLap(int lap) {};
+    virtual void update (float delta) OVERRIDE;
+    virtual void reset  () OVERRIDE;
+    virtual void newLap (int lap) OVERRIDE {}
 };
 
 #endif

src/karts/controller/battle_ai.cpp

@@ -159,3 +159,9 @@ float BattleAI::getKartDistance(int to_id) const
 {
     return m_graph->getDistance(getCurrentNode(), m_world->getKartNode(to_id));
 }   // getKartDistance
+
+//-----------------------------------------------------------------------------
+bool BattleAI::isKartOnRoad() const
+{
+    return m_world->isOnRoad(m_kart->getWorldKartId());
+}   // isKartOnRoad

src/karts/controller/battle_ai.hpp

@@ -34,16 +34,17 @@ private:
     /** Keep a pointer to world. */
     ThreeStrikesBattle *m_world;
 
-    virtual void findClosestKart(bool use_difficulty);
-    virtual void findTarget();
-    virtual int  getCurrentNode() const;
-    virtual bool isWaiting() const;
-    virtual float getKartDistance(int to_id) const;
+    virtual void  findClosestKart(bool use_difficulty) OVERRIDE;
+    virtual void  findTarget() OVERRIDE;
+    virtual int   getCurrentNode() const OVERRIDE;
+    virtual float getKartDistance(int to_id) const OVERRIDE;
+    virtual bool  isKartOnRoad() const OVERRIDE;
+    virtual bool  isWaiting() const OVERRIDE;
 public:
                  BattleAI(AbstractKart *kart);
                 ~BattleAI();
-    virtual void update      (float delta);
-    virtual void reset       ();
+    virtual void update  (float delta) OVERRIDE;
+    virtual void reset   () OVERRIDE;
 };
 
 #endif

src/karts/controller/soccer_ai.cpp

@@ -467,3 +467,9 @@ float SoccerAI::getKartDistance(int to_id) const
 {
     return m_graph->getDistance(getCurrentNode(), m_world->getKartNode(to_id));
 }   // getKartDistance
+
+//-----------------------------------------------------------------------------
+bool SoccerAI::isKartOnRoad() const
+{
+    return m_world->isOnRoad(m_kart->getWorldKartId());
+}   // isKartOnRoad

src/karts/controller/soccer_ai.hpp

@@ -57,29 +57,30 @@ private:
 
     btTransform m_front_transform;
 
-    Vec3 determineBallAimingPosition();
-    bool isOvertakable(const Vec3& ball_lc);
-    bool determineOvertakePosition(const Vec3& ball_lc, const Vec3& aim_lc,
-                                   Vec3* overtake_lc);
+    Vec3  determineBallAimingPosition();
+    bool  determineOvertakePosition(const Vec3& ball_lc, const Vec3& aim_lc,
+                                    Vec3* overtake_lc);
+    bool  isOvertakable(const Vec3& ball_lc);
     float rotateSlope(float old_slope, bool rotate_up);
 
-    virtual void findClosestKart(bool use_difficulty);
-    virtual void findTarget();
-    virtual void resetAfterStop() OVERRIDE    { m_overtake_ball = false; }
-    virtual int  getCurrentNode() const;
-    virtual float getKartDistance(int to_id) const;
-    virtual bool isWaiting() const;
-    virtual bool canSkid(float steer_fraction)
+    virtual bool  canSkid(float steer_fraction) OVERRIDE
            { return m_mini_skid && !(m_overtake_ball || m_chasing_ball); }
-    virtual bool forceBraking() OVERRIDE
+    virtual void  findClosestKart(bool use_difficulty) OVERRIDE;
+    virtual void  findTarget() OVERRIDE;
+    virtual bool  forceBraking() OVERRIDE
                               { return m_avoiding_item || m_force_brake; }
-    virtual bool ignorePathFinding() OVERRIDE
+    virtual int   getCurrentNode() const OVERRIDE;
+    virtual float getKartDistance(int to_id) const OVERRIDE;
+    virtual bool  ignorePathFinding() OVERRIDE
                             { return  m_overtake_ball || m_chasing_ball; }
+    virtual bool  isKartOnRoad() const OVERRIDE;
+    virtual bool  isWaiting() const OVERRIDE;
+    virtual void  resetAfterStop() OVERRIDE   { m_overtake_ball = false; }
 public:
                  SoccerAI(AbstractKart *kart);
                 ~SoccerAI();
-    virtual void update      (float delta);
-    virtual void reset       ();
+    virtual void update  (float delta) OVERRIDE;
+    virtual void reset   () OVERRIDE;
 };
 
 #endif

src/modes/soccer_world.cpp

@@ -756,3 +756,10 @@ void SoccerWorld::setAITeam()
     Log::debug("SoccerWorld","blue AI: %d red AI: %d", m_blue_ai, m_red_ai);
 
 }   // setAITeam
+
+//-----------------------------------------------------------------------------
+bool SoccerWorld::isOnRoad(unsigned int kart_id) const
+{
+    assert(m_kart_track_sector.size() > kart_id);
+    return m_kart_track_sector[kart_id]->isOnRoad();
+}   // isOnRoad

src/modes/soccer_world.hpp

@@ -358,6 +358,8 @@ public:
     // ------------------------------------------------------------------------
     int getKartNode(unsigned int kart_id) const;
     // ------------------------------------------------------------------------
+    bool isOnRoad(unsigned int kart_id) const;
+    // ------------------------------------------------------------------------
     int getBallNode() const;
     // ------------------------------------------------------------------------
     const Vec3& getBallPosition() const

src/modes/three_strikes_battle.cpp

@@ -565,3 +565,10 @@ void ThreeStrikesBattle::enterRaceOverState()
     }
 
 }   // enterRaceOverState
+
+//-----------------------------------------------------------------------------
+bool ThreeStrikesBattle::isOnRoad(unsigned int kart_id) const
+{
+    assert(m_kart_track_sector.size() > kart_id);
+    return m_kart_track_sector[kart_id]->isOnRoad();
+}   // isOnRoad

src/modes/three_strikes_battle.hpp

@@ -119,7 +119,7 @@ public:
     virtual void enterRaceOverState() OVERRIDE;
 
     int getKartNode(unsigned int kart_id) const;
-
+    bool isOnRoad(unsigned int kart_id) const;
     void updateKartRanks();
     void increaseRescueCount() { m_total_rescue++; }
 };   // ThreeStrikesBattles