Ticket #2094: MoveOptimization.2.patch

source/simulation2/components/CCmpPosition.cpp

@@ -238 +238 @@
 
         AdvertisePositionChanges();
     }
+    
+    virtual void MoveAndTurnTo(entity_pos_t x, entity_pos_t z, entity_angle_t ry)
+    {
+        m_X = x;
+        m_Z = z;
+        m_RotY = ry;
+        
+        if (!m_InWorld)
+        {
+            m_InWorld = true;
+            m_LastX = m_PrevX = m_X;
+            m_LastZ = m_PrevZ = m_Z;
+            m_LastYOffset = m_YOffset;
+        }
+        
+        AdvertisePositionChanges();
+    }
 
     virtual void JumpTo(entity_pos_t x, entity_pos_t z)
     {

source/simulation2/components/CCmpUnitMotion.cpp

@@ -53 +53 @@
  * (This could typically be 1, but we need some tolerance in case speeds
  * or turn lengths change.)
  */
-static const int WAYPOINT_ADVANCE_LOOKAHEAD_TURNS = 4;
+static const int WAYPOINT_ADVANCE_LOOKAHEAD_TURNS = 3;
 
 /**
  * Maximum range to restrict short path queries to. (Larger ranges are slower,
@@ -792 +792 @@
     }
 
     if (m_State == STATE_IDLE)
-    {
         return;
-    }
 
     switch (m_PathState)
     {
@@ -860 +858 @@
         // We want to move (at most) maxSpeed*dt units from pos towards the next waypoint
 
         fixed timeLeft = dt;
-
-        while (timeLeft > fixed::Zero())
+        fixed zero = fixed::Zero();
+        
+        while (timeLeft > zero)
         {
             // If we ran out of short path, we have to stop
             if (m_ShortPath.m_Waypoints.empty())
@@ -870 +869 @@
             CFixedVector2D target(m_ShortPath.m_Waypoints.back().x, m_ShortPath.m_Waypoints.back().z);
             CFixedVector2D offset = target - pos;
 
-            // Face towards the target
-            if (!offset.IsZero())
-            {
-                entity_angle_t angle = atan2_approx(offset.X, offset.Y);
-                cmpPosition->TurnTo(angle);
-            }
-
             // Work out how far we can travel in timeLeft
             fixed maxdist = maxSpeed.Multiply(timeLeft);
 
@@ -923 +915 @@
 
         // Update the Position component after our movement (if we actually moved anywhere)
         if (pos != initialPos)
-            cmpPosition->MoveTo(pos.X, pos.Y);
+        {
+            CFixedVector2D offset = pos - initialPos;
+            
+            // Face towards the target
+            entity_angle_t angle = atan2_approx(offset.X, offset.Y);
+            cmpPosition->MoveAndTurnTo(pos.X,pos.Y, angle);
 
-        // Calculate the mean speed over this past turn.
-        m_CurSpeed = cmpPosition->GetDistanceTravelled() / dt;
-
+            // Calculate the mean speed over this past turn.
+            m_CurSpeed = cmpPosition->GetDistanceTravelled() / dt;
+        }
+        
         if (wasObstructed)
         {
             // Oops, we hit something (very likely another unit).
             // Stop, and recompute the whole path.
             // TODO: if the target has UnitMotion and is higher priority,
             // we should wait a little bit.
-
+            // TODO: that's where we would push.
+            
+            m_CurSpeed = zero;
             RequestLongPath(pos, m_FinalGoal);
             m_PathState = PATHSTATE_WAITING_REQUESTING_LONG;
-
+            
             return;
         }
 
@@ -952 +952 @@
             // (or have reached it already), try to extend it
 
             entity_pos_t minDistance = basicSpeed.Multiply(dt) * WAYPOINT_ADVANCE_LOOKAHEAD_TURNS;
-            if (PathIsShort(m_ShortPath, pos, minDistance))
+            
+            CFixedVector2D distance = CFixedVector2D();
+            
+            if (!m_ShortPath.m_Waypoints.empty())
             {
+                CFixedVector2D wpoint(m_ShortPath.m_Waypoints[0].x,m_ShortPath.m_Waypoints[0].z);
+                distance = wpoint - pos;
+            }
+            if (distance.CompareLength(minDistance) <= 0)
+            {
                 // Start the path extension from the end of this short path
                 // (or our current position if no short path)
                 CFixedVector2D from = pos;
-                if (!m_ShortPath.m_Waypoints.empty())
+                if (!distance.IsZero())
                     from = CFixedVector2D(m_ShortPath.m_Waypoints[0].x, m_ShortPath.m_Waypoints[0].z);
 
                 if (PickNextLongWaypoint(from, ShouldAvoidMovingUnits()))
@@ -1118 +1126 @@
 
 bool CCmpUnitMotion::PathIsShort(const ICmpPathfinder::Path& path, CFixedVector2D from, entity_pos_t minDistance)
 {
-    CFixedVector2D pos = from;
     entity_pos_t distLeft = minDistance;
 
     for (ssize_t i = (ssize_t)path.m_Waypoints.size()-1; i >= 0; --i)
     {
         // Check if the next path segment is longer than the requested minimum
         CFixedVector2D waypoint(path.m_Waypoints[i].x, path.m_Waypoints[i].z);
-        CFixedVector2D delta = waypoint - pos;
+        CFixedVector2D delta = waypoint - from;
         if (delta.CompareLength(distLeft) > 0)
             return false;
 
         // Still short enough - prepare to check the next segment
         distLeft -= delta.Length();
-        pos = waypoint;
+        from = waypoint;
     }
 
     // Reached the end of the path before exceeding minDistance

source/simulation2/components/ICmpPosition.cpp

@@ -25 +25 @@
 DEFINE_INTERFACE_METHOD_0("IsInWorld", bool, ICmpPosition, IsInWorld)
 DEFINE_INTERFACE_METHOD_0("MoveOutOfWorld", void, ICmpPosition, MoveOutOfWorld)
 DEFINE_INTERFACE_METHOD_2("MoveTo", void, ICmpPosition, MoveTo, entity_pos_t, entity_pos_t)
+DEFINE_INTERFACE_METHOD_3("MoveAndTurnTo", void, ICmpPosition, MoveAndTurnTo, entity_pos_t, entity_pos_t, entity_pos_t)
 DEFINE_INTERFACE_METHOD_2("JumpTo", void, ICmpPosition, JumpTo, entity_pos_t, entity_pos_t)
 DEFINE_INTERFACE_METHOD_1("SetHeightOffset", void, ICmpPosition, SetHeightOffset, entity_pos_t)
 DEFINE_INTERFACE_METHOD_0("GetHeightOffset", entity_pos_t, ICmpPosition, GetHeightOffset)

source/simulation2/components/ICmpPosition.h

@@ -74 +74 @@
     virtual void MoveTo(entity_pos_t x, entity_pos_t z) = 0;
 
     /**
+     * Combines MoveTo and TurnTo to avoid an uncessary "AdvertisePositionChange"
+     */
+    virtual void MoveAndTurnTo(entity_pos_t x, entity_pos_t z, entity_angle_t ry) = 0;
+
+    /**
      * Move immediately to the given location, with no interpolation.
      */
     virtual void JumpTo(entity_pos_t x, entity_pos_t z) = 0;