Improved skidding when closing to item or kart as target

src/karts/controller/arena_ai.cpp

@@ -23,7 +23,6 @@
 #include "items/powerup.hpp"
 #include "items/projectile_manager.hpp"
 #include "karts/abstract_kart.hpp"
-#include "karts/controller/player_controller.hpp"
 #include "karts/controller/ai_properties.hpp"
 #include "karts/kart_properties.hpp"
 #include "tracks/arena_graph.hpp"
@@ -63,6 +62,7 @@ void ArenaAI::reset()
     m_time_since_uturn = 0.0f;
     m_turn_radius = 0.0f;
     m_turn_angle = 0.0f;
+    m_steering_angle = 0.0f;
     m_on_node.clear();
     m_aiming_points.clear();
     m_aiming_nodes.clear();
@@ -106,6 +106,7 @@ void ArenaAI::update(float dt)
     // After found target, convert it to local coordinate, used for skidding or
     // u-turn
     m_target_point_lc = m_kart->getTrans().inverse()(m_target_point);
+    doSkiddingTest();
     handleArenaItems(dt);
 
     if (m_kart->getSpeed() > 15.0f && m_turn_angle < 20)
@@ -216,8 +217,8 @@ void ArenaAI::handleArenaSteering(const float dt)
         }
         else
         {
-            float target_angle = steerToPoint(m_target_point);
-            setSteering(target_angle, dt);
+            m_steering_angle = steerToPoint(m_target_point);
+            setSteering(m_steering_angle, dt);
         }
         return;
     }
@@ -242,8 +243,8 @@ void ArenaAI::handleArenaSteering(const float dt)
         }
         else
         {
-            float target_angle = steerToPoint(m_target_point);
-            setSteering(target_angle, dt);
+            m_steering_angle = steerToPoint(m_target_point);
+            setSteering(m_steering_angle, dt);
         }
         return;
     }
@@ -713,3 +714,27 @@ void ArenaAI::collectItemInArena(Vec3* aim_point, int* target_node) const
         *target_node = m_closest_kart_node;
     }
 }   // collectItemInArena
+
+//-----------------------------------------------------------------------------
+void ArenaAI::doSkiddingTest()
+{
+    m_mini_skid = false;
+
+    // No skidding when u-turn
+    if (m_is_uturn) return;
+
+    // Skid when close to target, but not straight ahead, in front of it, same
+    // steering side and with suitable difficulties.
+    const float abs_angle = atan2f(fabsf(m_target_point_lc.x()),
+        fabsf(m_target_point_lc.z()));
+    if ((m_cur_difficulty == RaceManager::DIFFICULTY_HARD ||
+        m_cur_difficulty == RaceManager::DIFFICULTY_BEST) &&
+        m_target_point_lc.z() > 0 && abs_angle > 0.15f &&
+        m_target_point_lc.length() < 10.0f &&
+        ((m_steering_angle < 0 && m_target_point_lc.x() < 0) ||
+        (m_steering_angle > 0 && m_target_point_lc.x() > 0)))
+    {
+        m_mini_skid = true;
+    }
+
+}   // doSkiddingTest

src/karts/controller/arena_ai.hpp

@@ -22,7 +22,7 @@
 #include "karts/controller/ai_base_controller.hpp"
 #include "race/race_manager.hpp"
 
-#define AI_DEBUG
+#undef AI_DEBUG
 #ifdef AI_DEBUG
 #include "graphics/irr_driver.hpp"
 #endif
@@ -65,8 +65,9 @@ protected:
 
     bool m_avoiding_item;
 
+    bool m_mini_skid;
+
     void  collectItemInArena(Vec3*, int*) const;
-    float findAngleFrom3Edges(float a, float b, float c);
 private:
     /** Used by handleArenaUTurn, it tells whether to do left or right
      *  turning when steering is overridden. */
@@ -100,6 +101,7 @@ private:
 
     float m_turn_radius;
     float m_turn_angle;
+    float m_steering_angle;
 
     Vec3 m_current_forward_point;
     int m_current_forward_node;
@@ -107,9 +109,9 @@ private:
     std::set<int> m_aiming_nodes;
     std::vector<Vec3> m_aiming_points;
 
-    bool m_mini_skid;
-
     void         checkIfStuck(const float dt);
+    void         doSkiddingTest();
+    float        findAngleFrom3Edges(float a, float b, float c);
     void         handleArenaAcceleration(const float dt);
     void         handleArenaBraking();
     void         handleArenaItems(const float dt);

src/karts/controller/soccer_ai.hpp

@@ -65,7 +65,8 @@ private:
     virtual int  getCurrentNode() const;
     virtual float getKartDistance(int to_id) const;
     virtual bool isWaiting() const;
-    virtual bool canSkid(float steer_fraction)           { return false; }
+    virtual bool canSkid(float steer_fraction)
+           { return m_mini_skid && !(m_overtake_ball || m_chasing_ball); }
     virtual bool forceBraking() OVERRIDE
                               { return m_avoiding_item || m_force_brake; }
     virtual bool ignorePathFinding() OVERRIDE

src/modes/soccer_world.cpp

@@ -25,13 +25,11 @@
 #include "graphics/central_settings.hpp"
 #include "graphics/irr_driver.hpp"
 #include "graphics/render_info.hpp"
-#include "karts/abstract_kart.hpp"
 #include "karts/kart.hpp"
 #include "karts/kart_model.hpp"
 #include "karts/kart_properties.hpp"
 #include "karts/rescue_animation.hpp"
 #include "karts/controller/local_player_controller.hpp"
-#include "karts/controller/soccer_ai.hpp"
 #include "physics/physics.hpp"
 #include "states_screens/race_gui_base.hpp"
 #include "tracks/track.hpp"