Ticket #4420: unitMotionRewrite.patch

binaries/data/mods/public/simulation/components/Formation.js

@@ -865 +865 @@
     {
         var cmpUnitMotion = Engine.QueryInterface(ent, IID_UnitMotion);
         if (cmpUnitMotion)
-            minSpeed = Math.min(minSpeed, cmpUnitMotion.GetWalkSpeed());
+            minSpeed = Math.min(minSpeed, cmpUnitMotion.GetSpeed());
     }
     minSpeed *= this.GetSpeedMultiplier();
 

binaries/data/mods/public/simulation/components/GuiInterface.js

@@ -596 +596 @@
     let cmpUnitMotion = Engine.QueryInterface(ent, IID_UnitMotion);
     if (cmpUnitMotion)
         ret.speed = {
-            "walk": cmpUnitMotion.GetWalkSpeed(),
-            "run": cmpUnitMotion.GetRunSpeed()
+            "walk": cmpUnitMotion.GetSpeed(),
+            "run": cmpUnitMotion.GetSpeed() * cmpUnitMotion.GetTopSpeedRatio()
         };
 
     return ret;

binaries/data/mods/public/simulation/components/UnitAI.js

@@ +1 @@
+const WALKING_SPEED = 1.0
+
 function UnitAI() {}
 
 UnitAI.prototype.Schema =
@@ -1391 +1393 @@
             "enter": function () {
                 var cmpFormation = Engine.QueryInterface(this.formationController, IID_Formation);
                 var cmpVisual = Engine.QueryInterface(this.entity, IID_Visual);
-                if (cmpFormation && cmpVisual)
+/* TOREPLACE                if (cmpFormation && cmpVisual)
                 {
                     cmpVisual.ReplaceMoveAnimation("walk", cmpFormation.GetFormationAnimation(this.entity, "walk"));
                     cmpVisual.ReplaceMoveAnimation("run", cmpFormation.GetFormationAnimation(this.entity, "run"));
                 }
+                */
                 this.SelectAnimation("move");
             },
 
@@ -1405 +1408 @@
                 // We can only finish this order if the move was really completed.
                 if (!msg.data.error && this.FinishOrder())
                     return;
-                var cmpVisual = Engine.QueryInterface(this.entity, IID_Visual);
+/* TOREPLACE                var cmpVisual = Engine.QueryInterface(this.entity, IID_Visual);
                 if (cmpVisual)
                 {
                     cmpVisual.ResetMoveAnimation("walk");
                     cmpVisual.ResetMoveAnimation("run");
                 }
-
+*/
                 var cmpFormation = Engine.QueryInterface(this.formationController, IID_Formation);
                 if (cmpFormation)
                     cmpFormation.SetInPosition(this.entity);
@@ -1699 +1702 @@
                 },
 
                 "leave": function(msg) {
-                    this.SetMoveSpeed(this.GetWalkSpeed());
+                    this.SetMoveSpeed(WALKING_SPEED);
                     this.StopTimer();
                 },
 
                 "MoveStarted": function(msg) {
                     // Adapt the speed to the one of the target if needed
-                    var cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
+                    let cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
                     if (cmpUnitMotion.IsInTargetRange(this.isGuardOf, 0, 3*this.guardRange))
                     {
-                        var cmpUnitAI = Engine.QueryInterface(this.isGuardOf, IID_UnitAI);
-                        if (cmpUnitAI)
+                        var cmpOtherMotion = Engine.QueryInterface(this.isGuardOf, IID_UnitMotion);
+                        if (cmpOtherMotion)
                         {
-                            var speed = cmpUnitAI.GetWalkSpeed();
-                            if (speed < this.GetWalkSpeed())
+                            let otherSpeed = cmpOtherMotion.GetSpeed();
+                            let mySpeed = cmpUnitMotion.GetSpeed();
+                            let speed = otherSpeed / mySpeed;
+                            if (speed < WALKING_SPEED)
                                 this.SetMoveSpeed(speed);
                         }
                     }
                 },
 
                 "MoveCompleted": function() {
-                    this.SetMoveSpeed(this.GetWalkSpeed());
+                    this.SetMoveSpeed(WALKING_SPEED);
                     if (!this.MoveToTargetRangeExplicit(this.isGuardOf, 0, this.guardRange))
                         this.SetNextState("GUARDING");
                 },
@@ -1774 +1779 @@
                 this.PlaySound("panic");
 
                 // Run quickly
-                var speed = this.GetRunSpeed();
-                this.SelectAnimation("move");
-                this.SetMoveSpeed(speed);
-            },
-
-            "HealthChanged": function() {
-                var speed = this.GetRunSpeed();
-                this.SetMoveSpeed(speed);
+                this.SetMoveSpeed(this.GetRunSpeed());
             },
 
             "leave": function() {
                 // Reset normal speed
-                this.SetMoveSpeed(this.GetWalkSpeed());
+                this.SetMoveSpeed(WALKING_SPEED);
             },
 
             "MoveCompleted": function() {
@@ -2100 +2098 @@
 
                     this.SelectAnimation("move");
                     var cmpUnitAI = Engine.QueryInterface(this.order.data.target, IID_UnitAI);
+                    // Run after a fleeing target
                     if (cmpUnitAI && cmpUnitAI.IsFleeing())
-                    {
-                        // Run after a fleeing target
-                        var speed = this.GetRunSpeed();
-                        this.SetMoveSpeed(speed);
-                    }
+                        this.SetMoveSpeed(this.GetRunSpeed());
                     this.StartTimer(1000, 1000);
                 },
 
@@ -2113 +2108 @@
                     var cmpUnitAI = Engine.QueryInterface(this.order.data.target, IID_UnitAI);
                     if (!cmpUnitAI || !cmpUnitAI.IsFleeing())
                         return;
-                    var speed = this.GetRunSpeed();
-                    this.SetMoveSpeed(speed);
+                    // TODO: figure out what to do with fleeing
+                    //var speed = this.GetRunSpeed();
+                    //this.SetMoveSpeed(speed);
                 },
 
                 "leave": function() {
                     // Reset normal speed in case it was changed
-                    this.SetMoveSpeed(this.GetWalkSpeed());
+                    this.SetMoveSpeed(WALKING_SPEED);
                     // Show carried resources when walking.
                     this.SetGathererAnimationOverride();
 
@@ -3227 +3223 @@
         "ROAMING": {
             "enter": function() {
                 // Walk in a random direction
-                this.SelectAnimation("walk", false, this.GetWalkSpeed());
                 this.MoveRandomly(+this.template.RoamDistance);
                 // Set a random timer to switch to feeding state
                 this.StartTimer(RandomInt(+this.template.RoamTimeMin, +this.template.RoamTimeMax));
@@ -4010 +4005 @@
 
 //// Message handlers /////
 
-UnitAI.prototype.OnMotionChanged = function(msg)
+UnitAI.prototype.OnBeginMove = function(msg)
+{
+    this.UnitFsm.ProcessMessage(this, {"type": "MoveStarted", "data": msg});
+};
+
+UnitAI.prototype.OnFinishedMove = function(msg)
 {
-    if (msg.starting && !msg.error)
-        this.UnitFsm.ProcessMessage(this, {"type": "MoveStarted", "data": msg});
-    else if (!msg.starting || msg.error)
-        this.UnitFsm.ProcessMessage(this, {"type": "MoveCompleted", "data": msg});
+    this.UnitFsm.ProcessMessage(this, {"type": "MoveCompleted", "data": msg});
 };
 
 UnitAI.prototype.OnGlobalConstructionFinished = function(msg)
@@ -4076 +4073 @@
 
 //// Helper functions to be called by the FSM ////
 
-UnitAI.prototype.GetWalkSpeed = function()
-{
-    var cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
-    return cmpUnitMotion.GetWalkSpeed();
-};
-
 UnitAI.prototype.GetRunSpeed = function()
 {
     var cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
-    var runSpeed = cmpUnitMotion.GetRunSpeed();
-    var walkSpeed = cmpUnitMotion.GetWalkSpeed();
-    if (runSpeed <= walkSpeed)
-        return runSpeed;
-    var cmpHealth = Engine.QueryInterface(this.entity, IID_Health);
-    var health = cmpHealth.GetHitpoints()/cmpHealth.GetMaxHitpoints();
-    return (health*runSpeed + (1-health)*walkSpeed);
+    return cmpUnitMotion.GetTopSpeedRatio();
 };
 
 /**
@@ -4290 +4275 @@
     // Remove the animation override, so that weapons are shown again.
     if (disable)
     {
-        cmpVisual.ResetMoveAnimation("walk");
+//TOREPLACE     cmpVisual.ResetMoveAnimation("walk");
         return;
     }
 
     // Work out what we're carrying, in order to select an appropriate animation
+    /*
     var type = cmpResourceGatherer.GetLastCarriedType();
     if (type)
     {
@@ -4304 +4290 @@
         if (type.specific == "meat")
             typename = "carry_" + type.specific;
 
-        cmpVisual.ReplaceMoveAnimation("walk", typename);
+//  TOREPLACE   cmpVisual.ReplaceMoveAnimation("walk", typename);
     }
     else
-        cmpVisual.ResetMoveAnimation("walk");
+        cmpVisual.ResetMoveAnimation("idle");
+    */
 };
 
 UnitAI.prototype.SelectAnimation = function(name, once, speed, sound)
@@ -4316 +4303 @@
     if (!cmpVisual)
         return;
 
-    // Special case: the "move" animation gets turned into a special
-    // movement mode that deals with speeds and walk/run automatically
-    if (name == "move")
-    {
-        // Speed to switch from walking to running animations
-        var runThreshold = (this.GetWalkSpeed() + this.GetRunSpeed()) / 2;
-
-        cmpVisual.SelectMovementAnimation(runThreshold);
-        return;
-    }
-
     var soundgroup;
     if (sound)
     {
@@ -4359 +4335 @@
 UnitAI.prototype.StopMoving = function()
 {
     var cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
-    cmpUnitMotion.StopMoving();
+    cmpUnitMotion.DiscardMove();
 };
 
 UnitAI.prototype.MoveToPoint = function(x, z)
 {
     var cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
+    cmpUnitMotion.SetAbortIfStuck(3);
     return cmpUnitMotion.MoveToPointRange(x, z, 0, 0);
 };
 
 UnitAI.prototype.MoveToPointRange = function(x, z, rangeMin, rangeMax)
 {
     var cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
+    cmpUnitMotion.SetAbortIfStuck(3);
     return cmpUnitMotion.MoveToPointRange(x, z, rangeMin, rangeMax);
 };
 
@@ -4380 +4358 @@
         return false;
 
     var cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
+    cmpUnitMotion.SetAbortIfStuck(5);
     return cmpUnitMotion.MoveToTargetRange(target, 0, 0);
 };
 
@@ -4394 +4373 @@
     var range = cmpRanged.GetRange(type);
 
     var cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
+    cmpUnitMotion.SetAbortIfStuck(5);
     return cmpUnitMotion.MoveToTargetRange(target, range.min, range.max);
 };
 
@@ -4450 +4430 @@
     var guessedMaxRange = (range.max + parabolicMaxRange)/2;
 
     var cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
+    cmpUnitMotion.SetAbortIfStuck(9);
     if (cmpUnitMotion.MoveToTargetRange(target, range.min, guessedMaxRange))
         return true;
 
@@ -4463 +4444 @@
         return false;
 
     var cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
+    cmpUnitMotion.SetAbortIfStuck(5);
     return cmpUnitMotion.MoveToTargetRange(target, min, max);
 };
 
@@ -4477 +4459 @@
     var range = cmpGarrisonHolder.GetLoadingRange();
 
     var cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
+    cmpUnitMotion.SetAbortIfStuck(5);
     return cmpUnitMotion.MoveToTargetRange(target, range.min, range.max);
 };
 
@@ -5694 +5677 @@
 UnitAI.prototype.SetMoveSpeed = function(speed)
 {
     var cmpMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
-    cmpMotion.SetSpeed(speed);
+    cmpMotion.SetSpeed(1.0);
 };
 
 UnitAI.prototype.SetHeldPosition = function(x, z)

binaries/data/mods/public/simulation/components/UnitMotionFlying.js

@@ -295 +295 @@
     return this.IsInPointRange(targetPos.x, targetPos.y, minRange, maxRange);
 };
 
-UnitMotionFlying.prototype.GetWalkSpeed = function()
+UnitMotionFlying.prototype.GetSpeed = function()
 {
     return +this.template.MaxSpeed;
 };

binaries/data/mods/public/simulation/data/pathfinder.xml

@@ -11 +11 @@
       <Obstructions>pathfinding</Obstructions>
       <MaxWaterDepth>2</MaxWaterDepth>
       <MaxTerrainSlope>1.0</MaxTerrainSlope>
-      <Clearance>0.8</Clearance>
+      <Clearance>0.7</Clearance>
     </default>
     <large>
       <Obstructions>pathfinding</Obstructions>

source/simulation2/MessageTypes.h

@@ -317 +317 @@
 };
 
 /**
- * Sent by CCmpUnitMotion during Update, whenever the motion status has changed
- * since the previous update.
+ * Sent by CCmpUnitMotion during Update,
+ * whenever we have started actually moving and were not moving before.
+ * We may or may not already have been trying to move
  */
-class CMessageMotionChanged : public CMessage
+class CMessageBeginMove : public CMessage
 {
 public:
-    DEFAULT_MESSAGE_IMPL(MotionChanged)
+    DEFAULT_MESSAGE_IMPL(BeginMove)
 
-    CMessageMotionChanged(bool starting, bool error) :
-        starting(starting), error(error)
+    CMessageBeginMove()
+    {
+    }
+};
+
+/**
+ * Sent by CCmpUnitMotion during Update,
+ * whenever we were actually moving before, and cannot continue
+ * this can be because we've arrived (failed=false) or we failed moving (failed=true)
+ * After this message is sent, the unit won't remove/repath without orders.
+ * Will never be sent on the same turn as MT_BeginMove.
+ */
+class CMessageFinishedMove : public CMessage
+{
+public:
+    DEFAULT_MESSAGE_IMPL(FinishedMove)
+
+    CMessageFinishedMove(bool fail) : failed(fail)
     {
     }
 
-    bool starting; // whether this is a start or end of movement
-    bool error; // whether we failed to start moving (couldn't find any path)
+    bool failed; // move failed
+};
+
+/**
+ * Sent by CCmpUnitMotion during Update,
+ * whenever we were actually moving before, and now stopped
+ * In this case, we will retry moving/pathing in the future on our own
+ * Unless ordered otherwise.
+ * We are just possibly stuck short-term, or must repath.
+ * Will never be sent on the same turn as MT_BeginMove.
+ */
+class CMessagePausedMove : public CMessage
+{
+public:
+    DEFAULT_MESSAGE_IMPL(PausedMove)
+
+    CMessagePausedMove()
+    {
+    }
 };
 
 /**

source/simulation2/TypeList.h

@@ -45 +45 @@
 MESSAGE(PositionChanged)
 MESSAGE(InterpolatedPositionChanged)
 MESSAGE(TerritoryPositionChanged)
-MESSAGE(MotionChanged)
+MESSAGE(BeginMove)
+MESSAGE(FinishedMove)
+MESSAGE(PausedMove)
 MESSAGE(RangeUpdate)
 MESSAGE(TerrainChanged)
 MESSAGE(VisibilityChanged)

source/simulation2/components/CCmpObstructionManager.cpp

@@ -1084 +1084 @@
             m_DebugOverlayLines.push_back(SOverlayLine());
             m_DebugOverlayLines.back().m_Color = defaultColor;
             float a = atan2f(it->second.v.X.ToFloat(), it->second.v.Y.ToFloat());
-            SimRender::ConstructSquareOnGround(GetSimContext(), it->second.x.ToFloat(), it->second.z.ToFloat(), it->second.hw.ToFloat()*2, it->second.hh.ToFloat()*2, a, m_DebugOverlayLines.back(), true);
+            SimRender::ConstructSquareOnGround(GetSimContext(), it->second.x.ToFloat(), it->second.z.ToFloat(), it->second.hw.ToFloat()*2 + 1, it->second.hh.ToFloat()*2 + 1, a, m_DebugOverlayLines.back(), true);
         }
 
         m_DebugOverlayDirty = false;

source/simulation2/components/CCmpPathfinder_Vertex.cpp

@@ -610 +610 @@
         // Check whether this is an axis-aligned square
         bool aa = (u.X == fixed::FromInt(1) && u.Y == fixed::Zero() && v.X == fixed::Zero() && v.Y == fixed::FromInt(1));
 
+        bool add = true;
         Vertex vert;
         vert.status = Vertex::UNEXPLORED;
         vert.quadInward = QUADRANT_NONE;
         vert.quadOutward = QUADRANT_ALL;
         vert.p.X = center.X - hd0.Dot(u); vert.p.Y = center.Y + hd0.Dot(v);
-        if (vert.p.X < rangeXMin) continue;
-        if (vert.p.Y < rangeZMin) continue;
-        if (vert.p.X > rangeXMax) continue;
-        if (vert.p.Y > rangeZMax) continue;
-        if (aa) vert.quadInward = QUADRANT_BR; vertexes.push_back(vert);
+        if (vert.p.X <= rangeXMin) add = false;
+        else if (vert.p.X >= rangeXMax) add = false;
+        else if (vert.p.Y <= rangeZMin) add = false;
+        else if (vert.p.Y >= rangeZMax) add = false;
+        if (aa) vert.quadInward = QUADRANT_BR;
+        if (add) vertexes.push_back(vert);
+        add = true;
         vert.p.X = center.X - hd1.Dot(u); vert.p.Y = center.Y + hd1.Dot(v);
-        if (vert.p.X < rangeXMin) continue;
-        if (vert.p.Y < rangeZMin) continue;
-        if (vert.p.X > rangeXMax) continue;
-        if (vert.p.Y > rangeZMax) continue;
-        if (aa) vert.quadInward = QUADRANT_TR; vertexes.push_back(vert);
+        if (vert.p.X <= rangeXMin) add = false;
+        else if (vert.p.X >= rangeXMax) add = false;
+        else if (vert.p.Y <= rangeZMin) add = false;
+        else if (vert.p.Y >= rangeZMax) add = false;
+        if (aa) vert.quadInward = QUADRANT_TR;
+        if (add) vertexes.push_back(vert);
+        add = true;
         vert.p.X = center.X + hd0.Dot(u); vert.p.Y = center.Y - hd0.Dot(v);
-        if (vert.p.X < rangeXMin) continue;
-        if (vert.p.Y < rangeZMin) continue;
-        if (vert.p.X > rangeXMax) continue;
-        if (vert.p.Y > rangeZMax) continue;
-        if (aa) vert.quadInward = QUADRANT_TL; vertexes.push_back(vert);
+        if (vert.p.X <= rangeXMin) add = false;
+        else if (vert.p.X >= rangeXMax) add = false;
+        else if (vert.p.Y <= rangeZMin) add = false;
+        else if (vert.p.Y >= rangeZMax) add = false;
+        if (aa) vert.quadInward = QUADRANT_TL;
+        if (add) vertexes.push_back(vert);
+        add = true;
         vert.p.X = center.X + hd1.Dot(u); vert.p.Y = center.Y - hd1.Dot(v);
-        if (vert.p.X < rangeXMin) continue;
-        if (vert.p.Y < rangeZMin) continue;
-        if (vert.p.X > rangeXMax) continue;
-        if (vert.p.Y > rangeZMax) continue;
-        if (aa) vert.quadInward = QUADRANT_BL; vertexes.push_back(vert);
+        if (vert.p.X <= rangeXMin) add = false;
+        else if (vert.p.X >= rangeXMax) add = false;
+        else if (vert.p.Y <= rangeZMin) add = false;
+        else if (vert.p.Y >= rangeZMax) add = false;
+        if (aa) vert.quadInward = QUADRANT_BL;
+        if (add) vertexes.push_back(vert);
 
         // Add the edges:
 
@@ -658 +666 @@
             edges.emplace_back(Edge{ ev3, ev0 });
         }
 
-        // TODO: should clip out vertexes and edges that are outside the range,
-        // to reduce the search space
     }
 
     // Add terrain obstructions

source/simulation2/components/CCmpUnitMotion.cpp

@@ -27 +27 @@
 #include "simulation2/components/ICmpPathfinder.h"
 #include "simulation2/components/ICmpRangeManager.h"
 #include "simulation2/components/ICmpValueModificationManager.h"
+#include "simulation2/components/ICmpVisual.h"
 #include "simulation2/helpers/Geometry.h"
 #include "simulation2/helpers/Render.h"
 #include "simulation2/MessageTypes.h"
@@ -106 +107 @@
  */
 static const fixed CHECK_TARGET_MOVEMENT_MIN_COS = fixed::FromInt(866)/1000;
 
+/**
+ * See unitmotion logic for details. Higher means units will retry more often before potentially failing.
+ */
+static const size_t MAX_PATH_REATTEMPS = 8;
+
 static const CColor OVERLAY_COLOR_LONG_PATH(1, 1, 1, 1);
 static const CColor OVERLAY_COLOR_SHORT_PATH(1, 0, 0, 1);
 
 class CCmpUnitMotion : public ICmpUnitMotion
 {
+private:
+    struct SMotionGoal
+    {
+    private:
+        bool m_Valid = false;
+
+        entity_pos_t m_TargetMinRange;
+        entity_pos_t m_TargetMaxRange;
+
+        entity_id_t m_TargetEntity;
+        // pathfinder-compliant goal.
+        PathGoal m_Goal;
+    public:
+        SMotionGoal() : m_Valid(false) {};
+        
+        SMotionGoal(PathGoal& goal, entity_pos_t minRange, entity_pos_t maxRange)
+        {
+            m_TargetEntity = INVALID_ENTITY;
+
+            m_TargetMinRange = minRange;
+            m_TargetMaxRange = maxRange;
+
+            m_Goal = goal;
+            m_Valid = true;
+        }
+
+        SMotionGoal(const CSimContext& context, entity_id_t target, PathGoal& goal, entity_pos_t minRange, entity_pos_t maxRange)
+        {
+            m_TargetEntity = target;
+            m_TargetMinRange = minRange;
+            m_TargetMaxRange = maxRange;
+
+            m_Goal = goal;
+            m_Valid = true;
+
+            UpdateTargetPosition(context);
+        }
+
+        const PathGoal& Goal() const { return m_Goal; };
+
+        bool TargetIsEntity() const { return m_TargetEntity != INVALID_ENTITY; }
+        entity_id_t GetEntity() const { return m_TargetEntity; }
+
+        bool Valid() const { return m_Valid; }
+        void Clear() { m_Valid = false; }
+
+        entity_pos_t MinRange() const { return m_TargetMinRange; };
+        entity_pos_t MaxRange() const { return m_TargetMaxRange; };
+
+        CFixedVector2D Pos() const { return CFixedVector2D(m_Goal.x, m_Goal.z); }
+        entity_pos_t X() const { return m_Goal.x; }
+        entity_pos_t Z() const { return m_Goal.z; }
+
+        void UpdateTargetPosition(const CSimContext& context)
+        {
+            if (!TargetIsEntity())
+                return;
+
+            CmpPtr<ICmpPosition> cmpPosition(context, m_TargetEntity);
+            if (!cmpPosition || !cmpPosition->IsInWorld())
+                return;
+
+            m_Goal.x = cmpPosition->GetPosition2D().X;
+            m_Goal.z = cmpPosition->GetPosition2D().Y;
+        }
+
+        bool IsAPoint() const
+        {
+            return m_Goal.type == PathGoal::POINT && !TargetIsEntity();
+        }
+    };
+
 public:
     static void ClassInit(CComponentManager& componentManager)
     {
-        componentManager.SubscribeToMessageType(MT_Update_MotionFormation);
         componentManager.SubscribeToMessageType(MT_Update_MotionUnit);
         componentManager.SubscribeToMessageType(MT_PathResult);
         componentManager.SubscribeToMessageType(MT_OwnershipChanged);
@@ -128 +205 @@
     std::vector<SOverlayLine> m_DebugOverlayLongPathLines;
     std::vector<SOverlayLine> m_DebugOverlayShortPathLines;
 
-    // Template state:
-
-    bool m_FormationController;
-    fixed m_WalkSpeed, m_OriginalWalkSpeed; // in metres per second
-    fixed m_RunSpeed, m_OriginalRunSpeed;
+    // Template state, never changed after init.
+    fixed m_TemplateSpeed, m_TopSpeedRatio;
     pass_class_t m_PassClass;
     std::string m_PassClassName;
-
-    // Dynamic state:
-
     entity_pos_t m_Clearance;
-    bool m_Moving;
-    bool m_FacePointAfterMove;
-
-    enum State
-    {
-        /*
-         * Not moving at all.
-         */
-        STATE_IDLE,
-
-        /*
-         * Not moving at all. Will go to IDLE next turn.
-         * (This one-turn delay is a hack to fix animation timings.)
-         */
-        STATE_STOPPING,
-
-        /*
-         * Member of a formation.
-         * Pathing to the target (depending on m_PathState).
-         * Target is m_TargetEntity plus m_TargetOffset.
-         */
-        STATE_FORMATIONMEMBER_PATH,
-
-        /*
-         * Individual unit or formation controller.
-         * Pathing to the target (depending on m_PathState).
-         * Target is m_TargetPos, m_TargetMinRange, m_TargetMaxRange;
-         * if m_TargetEntity is not INVALID_ENTITY then m_TargetPos is tracking it.
-         */
-        STATE_INDIVIDUAL_PATH,
-
-        STATE_MAX
-    };
-    u8 m_State;
-
-    enum PathState
-    {
-        /*
-         * There is no path.
-         * (This should only happen in IDLE and STOPPING.)
-         */
-        PATHSTATE_NONE,
-
-        /*
-         * We have an outstanding long path request.
-         * No paths are usable yet, so we can't move anywhere.
-         */
-        PATHSTATE_WAITING_REQUESTING_LONG,
-
-        /*
-         * We have an outstanding short path request.
-         * m_LongPath is valid.
-         * m_ShortPath is not yet valid, so we can't move anywhere.
-         */
-        PATHSTATE_WAITING_REQUESTING_SHORT,
-
-        /*
-         * We are following our path, and have no path requests.
-         * m_LongPath and m_ShortPath are valid.
-         */
-        PATHSTATE_FOLLOWING,
-
-        /*
-         * We are following our path, and have an outstanding long path request.
-         * (This is because our target moved a long way and we need to recompute
-         * the whole path).
-         * m_LongPath and m_ShortPath are valid.
-         */
-        PATHSTATE_FOLLOWING_REQUESTING_LONG,
-
-        /*
-         * We are following our path, and have an outstanding short path request.
-         * (This is because our target moved and we've got a new long path
-         * which we need to follow).
-         * m_LongPath is valid; m_ShortPath is valid but obsolete.
-         */
-        PATHSTATE_FOLLOWING_REQUESTING_SHORT,
-
-        PATHSTATE_MAX
-    };
-    u8 m_PathState;
-
-    u32 m_ExpectedPathTicket; // asynchronous request ID we're waiting for, or 0 if none
-
-    entity_id_t m_TargetEntity;
-    CFixedVector2D m_TargetPos;
-    CFixedVector2D m_TargetOffset;
-    entity_pos_t m_TargetMinRange;
-    entity_pos_t m_TargetMaxRange;
 
+    // TARGET
+    // As long as we have a valid target, the unit is considered "on the move".
+    // It may not be actually moving for a variety of reasons (no path, blocked path)… but it will shortly.
+    SMotionGoal m_FinalGoal;
+    
+    // MOTION PLANNING
+    // We will abort if we are stuck after X tries.
+    u8 m_AbortIfStuck;
+    // turn towards our target at the end
+    bool m_FacePointAfterMove;
+    // actual unit speed, after technology and ratio
     fixed m_Speed;
+    // cached for convenience
+    fixed m_SpeedRatio;
 
-    // Current mean speed (over the last turn).
-    fixed m_CurSpeed;
+    // asynchronous request ID we're waiting for, or 0 if none
+    u32 m_ExpectedPathTicket;
 
     // Currently active paths (storing waypoints in reverse order).
     // The last item in each path is the point we're currently heading towards.
-    WaypointPath m_LongPath;
-    WaypointPath m_ShortPath;
-
-    // Motion planning
-    u8 m_Tries; // how many tries we've done to get to our current Final Goal.
-
-    PathGoal m_FinalGoal;
+    WaypointPath m_Path;
+    // used for the short pathfinder, incremented on each unsuccessful try.
+    u8 m_Tries;
+    // Turns to wait before a certain action.
+    u8 m_WaitingTurns;
+    // if we actually started moving at some point.
+    bool m_StartedMoving;
+
+    // Speed over the last turn
+    // cached for components that want it
+    fixed m_ActualSpeed;
 
     static std::string GetSchema()
     {
@@ -276 +275 @@
 
     virtual void Init(const CParamNode& paramNode)
     {
-        m_FormationController = paramNode.GetChild("FormationController").ToBool();
-
-        m_Moving = false;
         m_FacePointAfterMove = true;
 
-        m_WalkSpeed = m_OriginalWalkSpeed = paramNode.GetChild("WalkSpeed").ToFixed();
-        m_Speed = m_WalkSpeed;
-        m_CurSpeed = fixed::Zero();
+        m_TemplateSpeed = m_Speed = paramNode.GetChild("WalkSpeed").ToFixed();
+        m_ActualSpeed = fixed::Zero();
+        m_SpeedRatio = fixed::FromInt(1);
 
-        if (paramNode.GetChild("Run").IsOk())
-            m_RunSpeed = m_OriginalRunSpeed = paramNode.GetChild("Run").GetChild("Speed").ToFixed();
-        else
-            m_RunSpeed = m_OriginalRunSpeed = m_WalkSpeed;
+        m_TopSpeedRatio = fixed::FromInt(1);
+        if (paramNode.GetChild("RunMultiplier").IsOk())
+            m_TopSpeedRatio = paramNode.GetChild("WalkSpeed").ToFixed();
 
         CmpPtr<ICmpPathfinder> cmpPathfinder(GetSystemEntity());
         if (cmpPathfinder)
@@ -302 +297 @@
                 cmpObstruction->SetUnitClearance(m_Clearance);
         }
 
-        m_State = STATE_IDLE;
-        m_PathState = PATHSTATE_NONE;
-
         m_ExpectedPathTicket = 0;
 
         m_Tries = 0;
-
-        m_TargetEntity = INVALID_ENTITY;
-
-        m_FinalGoal.type = PathGoal::POINT;
+        m_WaitingTurns = 0;
 
         m_DebugOverlayEnabled = false;
+        m_AbortIfStuck = 0;
     }
 
     virtual void Deinit()
@@ -323 +313 @@
     template<typename S>
     void SerializeCommon(S& serialize)
     {
-        serialize.NumberU8("state", m_State, 0, STATE_MAX-1);
+        /*serialize.NumberU8("state", m_State, 0, STATE_MAX-1);
         serialize.NumberU8("path state", m_PathState, 0, PATHSTATE_MAX-1);
 
         serialize.StringASCII("pass class", m_PassClassName, 0, 64);
@@ -339 +329 @@
         serialize.NumberFixed_Unbounded("target max range", m_TargetMaxRange);
 
         serialize.NumberFixed_Unbounded("speed", m_Speed);
-        serialize.NumberFixed_Unbounded("current speed", m_CurSpeed);
+        serialize.NumberFixed_Unbounded("current speed", m_ActualSpeed);
 
         serialize.Bool("moving", m_Moving);
         serialize.Bool("facePointAfterMove", m_FacePointAfterMove);
@@ -349 +339 @@
         SerializeVector<SerializeWaypoint>()(serialize, "long path", m_LongPath.m_Waypoints);
         SerializeVector<SerializeWaypoint>()(serialize, "short path", m_ShortPath.m_Waypoints);
 
-        SerializeGoal()(serialize, "goal", m_FinalGoal);
+        SerializeGoal()(serialize, "goal", m_FinalGoal);*/
     }
 
     virtual void Serialize(ISerializer& serialize)
@@ -359 +349 @@
 
     virtual void Deserialize(const CParamNode& paramNode, IDeserializer& deserialize)
     {
-        Init(paramNode);
+        /*Init(paramNode);
 
         SerializeCommon(deserialize);
 
         CmpPtr<ICmpPathfinder> cmpPathfinder(GetSystemEntity());
         if (cmpPathfinder)
-            m_PassClass = cmpPathfinder->GetPassabilityClass(m_PassClassName);
+            m_PassClass = cmpPathfinder->GetPassabilityClass(m_PassClassName);*/
     }
 
     virtual void HandleMessage(const CMessage& msg, bool UNUSED(global))
     {
         switch (msg.GetType())
         {
-        case MT_Update_MotionFormation:
-        {
-            if (m_FormationController)
-            {
-                fixed dt = static_cast<const CMessageUpdate_MotionFormation&> (msg).turnLength;
-                Move(dt);
-            }
-            break;
-        }
         case MT_Update_MotionUnit:
         {
-            if (!m_FormationController)
-            {
-                fixed dt = static_cast<const CMessageUpdate_MotionUnit&> (msg).turnLength;
-                Move(dt);
-            }
+            fixed dt = static_cast<const CMessageUpdate_MotionUnit&> (msg).turnLength;
+            Move(dt);
             break;
         }
         case MT_RenderSubmit:
@@ -417 +395 @@
             if (!cmpValueModificationManager)
                 break;
 
-            fixed newWalkSpeed = cmpValueModificationManager->ApplyModifications(L"UnitMotion/WalkSpeed", m_OriginalWalkSpeed, GetEntityId());
-            fixed newRunSpeed = cmpValueModificationManager->ApplyModifications(L"UnitMotion/Run/Speed", m_OriginalRunSpeed, GetEntityId());
-
-            // update m_Speed (the actual speed) if set to one of the variables
-            if (m_Speed == m_WalkSpeed)
-                m_Speed = newWalkSpeed;
-            else if (m_Speed == m_RunSpeed)
-                m_Speed = newRunSpeed;
+            m_Speed = m_SpeedRatio.Multiply(cmpValueModificationManager->ApplyModifications(L"UnitMotion/WalkSpeed", m_TemplateSpeed, GetEntityId()));
 
-            m_WalkSpeed = newWalkSpeed;
-            m_RunSpeed = newRunSpeed;
             break;
         }
         }
@@ -439 +408 @@
         GetSimContext().GetComponentManager().DynamicSubscriptionNonsync(MT_RenderSubmit, this, needRender);
     }
 
-    virtual bool IsMoving()
+    virtual bool IsActuallyMoving()
+    {
+        return m_StartedMoving;
+    }
+
+    virtual bool IsTryingToMove()
+    {
+        // speed check as sanity check to avoid infinite loops.
+        return m_FinalGoal.Valid() && m_Speed > fixed::Zero();
+    }
+
+    virtual fixed GetTemplateSpeed()
+    {
+        return m_TemplateSpeed;
+    }
+
+    virtual fixed GetSpeed()
     {
-        return m_Moving;
+        return m_Speed;
     }
 
-    virtual fixed GetWalkSpeed()
+    virtual fixed GetActualSpeed()
     {
-        return m_WalkSpeed;
+        return m_ActualSpeed;
     }
 
-    virtual fixed GetRunSpeed()
+    virtual fixed GetSpeedRatio()
     {
-        return m_RunSpeed;
+        return m_SpeedRatio;
+    }
+
+    virtual fixed GetTopSpeedRatio()
+    {
+        return m_TopSpeedRatio;
+    }
+
+    // don't call this all the time
+    // it's voluntarily too slow, because you shouldn't be doing this.
+    virtual void SetSpeed(fixed ratio)
+    {
+        m_SpeedRatio = ratio;
+        CmpPtr<ICmpValueModificationManager> cmpValueModificationManager(GetSystemEntity());
+        if (cmpValueModificationManager)
+        {
+            m_Speed = m_SpeedRatio.Multiply(cmpValueModificationManager->ApplyModifications(L"UnitMotion/WalkSpeed", m_TemplateSpeed, GetEntityId()));
+            return;
+        }
+
+        m_Speed = m_SpeedRatio.Multiply(m_TemplateSpeed);
     }
 
     virtual pass_class_t GetPassabilityClass()
@@ -472 +477 @@
             m_PassClass = cmpPathfinder->GetPassabilityClass(passClassName);
     }
 
-    virtual fixed GetCurrentSpeed()
-    {
-        return m_CurSpeed;
-    }
-
-    virtual void SetSpeed(fixed speed)
-    {
-        m_Speed = speed;
-    }
-
     virtual void SetFacePointAfterMove(bool facePointAfterMove)
     {
         m_FacePointAfterMove = facePointAfterMove;
@@ -493 +488 @@
         UpdateMessageSubscriptions();
     }
 
+    virtual entity_pos_t GetUnitClearance()
+    {
+        return m_Clearance;
+    }
+
     virtual bool MoveToPointRange(entity_pos_t x, entity_pos_t z, entity_pos_t minRange, entity_pos_t maxRange);
     virtual bool IsInPointRange(entity_pos_t x, entity_pos_t z, entity_pos_t minRange, entity_pos_t maxRange);
     virtual bool MoveToTargetRange(entity_id_t target, entity_pos_t minRange, entity_pos_t maxRange);
     virtual bool IsInTargetRange(entity_id_t target, entity_pos_t minRange, entity_pos_t maxRange);
-    virtual void MoveToFormationOffset(entity_id_t target, entity_pos_t x, entity_pos_t z);
 
     virtual void FaceTowardsPoint(entity_pos_t x, entity_pos_t z);
 
-    virtual void StopMoving()
+    virtual void SetAbortIfStuck(u8 shouldAbort)
     {
-        m_Moving = false;
-        m_ExpectedPathTicket = 0;
-        m_State = STATE_STOPPING;
-        m_PathState = PATHSTATE_NONE;
-        m_LongPath.m_Waypoints.clear();
-        m_ShortPath.m_Waypoints.clear();
+        m_AbortIfStuck = shouldAbort;
     }
 
-    virtual entity_pos_t GetUnitClearance()
+    virtual void DiscardMove()
     {
-        return m_Clearance;
+        StopMovingQuietly();
     }
 
-private:
-    bool ShouldAvoidMovingUnits() const
+    // stop moving and send message
+    virtual void CompleteMove()
     {
-        return !m_FormationController;
+        // highlight bugs.
+        if (!IsTryingToMove())
+        {
+            LOGERROR("Entity %i trying to stop moving but has not actually started", GetEntityId());
+            return;
+        }
+
+        StopMovingQuietly();
+
+        if (m_FacePointAfterMove)
+        {
+            CmpPtr<ICmpPosition> cmpPosition(GetEntityHandle());
+            if (cmpPosition && cmpPosition->IsInWorld())
+                FaceTowardsPointFromPos(cmpPosition->GetPosition2D(), m_FinalGoal.X(), m_FinalGoal.Z());
+        }
+
+        CMessageFinishedMove msg(false);
+        GetSimContext().GetComponentManager().PostMessage(GetEntityId(), msg);
     }
 
+private:
+/*
+ TODO: reimplement
     bool IsFormationMember() const
     {
         return m_State == STATE_FORMATIONMEMBER_PATH;
     }
-
+*/
     entity_id_t GetGroup() const
     {
-        return IsFormationMember() ? m_TargetEntity : GetEntityId();
+        //return IsFormationMember() ? m_TargetEntity : GetEntityId();
+        return GetEntityId();
     }
 
     bool HasValidPath() const
     {
-        return m_PathState == PATHSTATE_FOLLOWING
-            || m_PathState == PATHSTATE_FOLLOWING_REQUESTING_LONG
-            || m_PathState == PATHSTATE_FOLLOWING_REQUESTING_SHORT;
+        return !m_Path.m_Waypoints.empty();
     }
 
-    void StartFailed()
+    void StopMovingQuietly()
     {
-        StopMoving();
-        m_State = STATE_IDLE; // don't go through the STOPPING state since we never even started
+        // sanity
+        m_Tries = 0;
+        m_WaitingTurns = 0;
+        m_StartedMoving = false;
+
+        // reset state.
+        m_ExpectedPathTicket = 0;
+        m_FinalGoal.Clear();
+        m_Path.m_Waypoints.clear();
 
         CmpPtr<ICmpObstruction> cmpObstruction(GetEntityHandle());
         if (cmpObstruction)
             cmpObstruction->SetMovingFlag(false);
 
-        CMessageMotionChanged msg(true, true);
-        GetSimContext().GetComponentManager().PostMessage(GetEntityId(), msg);
+        CmpPtr<ICmpVisual> cmpVisualActor(GetEntityHandle());
+        if (cmpVisualActor)
+            cmpVisualActor->SetMoving(true);
     }
 
     void MoveFailed()
     {
-        StopMoving();
+        StopMovingQuietly();
 
-        CmpPtr<ICmpObstruction> cmpObstruction(GetEntityHandle());
-        if (cmpObstruction)
-            cmpObstruction->SetMovingFlag(false);
-
-        CMessageMotionChanged msg(false, true);
+        CMessageFinishedMove msg(true);
         GetSimContext().GetComponentManager().PostMessage(GetEntityId(), msg);
+        CmpPtr<ICmpVisual> cmpVisualActor(GetEntityHandle());
+        if (cmpVisualActor)
+            cmpVisualActor->SetMoving(false);
     }
 
-    void StartSucceeded()
+    void MovePaused()
     {
-        CmpPtr<ICmpObstruction> cmpObstruction(GetEntityHandle());
-        if (cmpObstruction)
-            cmpObstruction->SetMovingFlag(true);
+        m_StartedMoving = false;
 
-        m_Moving = true;
-
-        CMessageMotionChanged msg(true, false);
+        CMessagePausedMove msg;
         GetSimContext().GetComponentManager().PostMessage(GetEntityId(), msg);
+        CmpPtr<ICmpVisual> cmpVisualActor(GetEntityHandle());
+        if (cmpVisualActor)
+            cmpVisualActor->SetMoving(false);
     }
 
-    void MoveSucceeded()
+    void MoveStarted()
     {
-        m_Moving = false;
-
-        CmpPtr<ICmpObstruction> cmpObstruction(GetEntityHandle());
-        if (cmpObstruction)
-            cmpObstruction->SetMovingFlag(false);
+        m_StartedMoving = true;
 
-        // No longer moving, so speed is 0.
-        m_CurSpeed = fixed::Zero();
-
-        CMessageMotionChanged msg(false, false);
+        CMessageBeginMove msg;
         GetSimContext().GetComponentManager().PostMessage(GetEntityId(), msg);
+        CmpPtr<ICmpVisual> cmpVisualActor(GetEntityHandle());
+        if (cmpVisualActor)
+            cmpVisualActor->SetMoving(true);
     }
 
     bool MoveToPointRange(entity_pos_t x, entity_pos_t z, entity_pos_t minRange, entity_pos_t maxRange, entity_id_t target);
@@ -634 +649 @@
     bool CheckTargetMovement(const CFixedVector2D& from, entity_pos_t minDelta);
 
     /**
-     * Update goal position if moving target
-     */
-    void UpdateFinalGoal();
-
-    /**
      * Returns whether we are close enough to the target to assume it's a good enough
      * position to stop.
      */
-    bool ShouldConsiderOurselvesAtDestination(const CFixedVector2D& from);
+    bool ShouldConsiderOurselvesAtDestination();
 
     /**
      * Returns whether the length of the given path, plus the distance from
@@ -663 +673 @@
     ControlGroupMovementObstructionFilter GetObstructionFilter(bool noTarget = false) const;
 
     /**
-     * Start moving to the given goal, from our current position 'from'.
+     * Dump current paths and request a new one.
      * Might go in a straight line immediately, or might start an asynchronous
      * path request.
      */
-    void BeginPathing(const CFixedVector2D& from, const PathGoal& goal);
+    void RequestNewPath();
 
     /**
      * Start an asynchronous long path query.
@@ -691 +701 @@
 
 void CCmpUnitMotion::PathResult(u32 ticket, const WaypointPath& path)
 {
-    // reset our state for sanity.
-    CmpPtr<ICmpObstruction> cmpObstruction(GetEntityHandle());
-    if (cmpObstruction)
-        cmpObstruction->SetMovingFlag(false);
-
-    m_Moving = false;
-
     // Ignore obsolete path requests
     if (ticket != m_ExpectedPathTicket)
         return;
 
     m_ExpectedPathTicket = 0; // we don't expect to get this result again
 
-    // Check that we are still able to do something with that path
-    CmpPtr<ICmpPosition> cmpPosition(GetEntityHandle());
-    if (!cmpPosition || !cmpPosition->IsInWorld())
-    {
-        if (m_PathState == PATHSTATE_WAITING_REQUESTING_LONG || m_PathState == PATHSTATE_WAITING_REQUESTING_SHORT)
-            StartFailed();
-        else if (m_PathState == PATHSTATE_FOLLOWING_REQUESTING_LONG || m_PathState == PATHSTATE_FOLLOWING_REQUESTING_SHORT)
-            StopMoving();
+    if (!m_FinalGoal.Valid())
         return;
-    }
 
-    if (m_PathState == PATHSTATE_WAITING_REQUESTING_LONG || m_PathState == PATHSTATE_FOLLOWING_REQUESTING_LONG)
+    if (path.m_Waypoints.empty())
     {
-        m_LongPath = path;
+        // no waypoints, path failed.
+        // if we have some room, pop waypoint
+        // TODO: this isn't particularly bright.
+        if (!m_Path.m_Waypoints.empty())
+            m_Path.m_Waypoints.pop_back();
 
-        // If we are following a path, leave the old m_ShortPath so we can carry on following it
-        // until a new short path has been computed
-        if (m_PathState == PATHSTATE_WAITING_REQUESTING_LONG)
-            m_ShortPath.m_Waypoints.clear();
-
-        // If there's no waypoints then we couldn't get near the target.
-        // Sort of hack: Just try going directly to the goal point instead
-        // (via the short pathfinder), so if we're stuck and the user clicks
-        // close enough to the unit then we can probably get unstuck
-        if (m_LongPath.m_Waypoints.empty())
-            m_LongPath.m_Waypoints.emplace_back(Waypoint{ m_FinalGoal.x, m_FinalGoal.z });
-
-        if (!HasValidPath())
-            StartSucceeded();
-
-        m_PathState = PATHSTATE_FOLLOWING;
-
-        if (cmpObstruction)
-            cmpObstruction->SetMovingFlag(true);
-
-        m_Moving = true;
+        // we will then deal with this on the next Move() call.
+        return;
     }
-    else if (m_PathState == PATHSTATE_WAITING_REQUESTING_SHORT || m_PathState == PATHSTATE_FOLLOWING_REQUESTING_SHORT)
-    {
-        m_ShortPath = path;
-
-        // If there's no waypoints then we couldn't get near the target
-        if (m_ShortPath.m_Waypoints.empty())
-        {
-            // If we're globally following a long path, try to remove the next waypoint, it might be obstructed
-            // If not, and we are not in a formation, retry
-            // unless we are close to our target and we don't have a target entity.
-            // This makes sure that units don't clump too much when they are not in a formation and tasked to move.
-            if (m_LongPath.m_Waypoints.size() > 1)
-                m_LongPath.m_Waypoints.pop_back();
-            else if (IsFormationMember())
-            {
-                m_Moving = false;
-                CMessageMotionChanged msg(true, true);
-                GetSimContext().GetComponentManager().PostMessage(GetEntityId(), msg);
-                return;
-            }
-
-            CMessageMotionChanged msg(false, false);
-            GetSimContext().GetComponentManager().PostMessage(GetEntityId(), msg);
-
-            CmpPtr<ICmpPosition> cmpPosition(GetEntityHandle());
-            if (!cmpPosition || !cmpPosition->IsInWorld())
-                return;
 
-            CFixedVector2D pos = cmpPosition->GetPosition2D();
-
-            if (ShouldConsiderOurselvesAtDestination(pos))
-                return;
-
-            UpdateFinalGoal();
-            RequestLongPath(pos, m_FinalGoal);
-            m_PathState = PATHSTATE_WAITING_REQUESTING_LONG;
-            return;
-        }
-
-        // else we could, so reset our number of tries.
-        m_Tries = 0;
-
-        // Now we've got a short path that we can follow
-        if (!HasValidPath())
-            StartSucceeded();
-
-        m_PathState = PATHSTATE_FOLLOWING;
-
-        if (cmpObstruction)
-            cmpObstruction->SetMovingFlag(true);
-
-        m_Moving = true;
-    }
-    else
-        LOGWARNING("unexpected PathResult (%u %d %d)", GetEntityId(), m_State, m_PathState);
+    // add to the top of our current waypoints
+    m_Path.m_Waypoints.insert(m_Path.m_Waypoints.end(), path.m_Waypoints.begin(), path.m_Waypoints.end());
 }
 
 void CCmpUnitMotion::Move(fixed dt)
 {
     PROFILE("Move");
 
-    if (m_State == STATE_STOPPING)
+    /**
+     * TODO: the visual actor doesn't interpolate, it merely changes things on update
+     * This means if a unit wants to change animation between turns (because it stops…)
+     * It will look slightly glitchy for a very short while
+     */
+
+    if (!IsTryingToMove())
     {
-        m_State = STATE_IDLE;
-        MoveSucceeded();
+        m_ActualSpeed = fixed::Zero();
         return;
     }
 
-    if (m_State == STATE_IDLE)
+    m_FinalGoal.UpdateTargetPosition(GetSimContext());
+
+    // TODO: units will look at each other's position in an arbitrary order that must be the same for any simulation
+    // In particular this means no threading. Maybe we should update this someday if it's possible.
+
+    CmpPtr<ICmpPathfinder> cmpPathfinder(GetSystemEntity());
+    if (!cmpPathfinder)
         return;
 
-    switch (m_PathState)
-    {
-    case PATHSTATE_NONE:
-    {
-        // If we're not pathing, do nothing
+    CmpPtr<ICmpPosition> cmpPosition(GetEntityHandle());
+    if (!cmpPosition || !cmpPosition->IsInWorld())
         return;
-    }
 
-    case PATHSTATE_WAITING_REQUESTING_LONG:
-    case PATHSTATE_WAITING_REQUESTING_SHORT:
+    CFixedVector2D initialPos = cmpPosition->GetPosition2D();
+
+    // Preliminary check: our target may be an entity and may have moved before us
+    if (ShouldConsiderOurselvesAtDestination())
     {
-        // If we're waiting for a path and don't have one yet, do nothing
+        CompleteMove();
         return;
     }
 
-    case PATHSTATE_FOLLOWING:
-    case PATHSTATE_FOLLOWING_REQUESTING_SHORT:
-    case PATHSTATE_FOLLOWING_REQUESTING_LONG:
-    {
-        // TODO: there's some asymmetry here when units look at other
-        // units' positions - the result will depend on the order of execution.
-        // Maybe we should split the updates into multiple phases to minimise
-        // that problem.
+    // TODO: here should go things such as:
+    // - has our target moved enough that we should re-path?
+    // end TODO
 
-        CmpPtr<ICmpPathfinder> cmpPathfinder(GetSystemEntity());
-        if (!cmpPathfinder)
-            return;
+    // Keep track of the current unit's position during the update
+    CFixedVector2D pos = initialPos;
 
-        CmpPtr<ICmpPosition> cmpPosition(GetEntityHandle());
-        if (!cmpPosition || !cmpPosition->IsInWorld())
-            return;
+    // Find the speed factor of the underlying terrain
+    // (We only care about the tile we start on - it doesn't matter if we're moving
+    // partially onto a much slower/faster tile)
+    // TODO: Terrain-dependent speeds are not currently supported
+    // TODO: note that this is also linked to pathfinding so maybe never supported
+    // fixed terrainSpeed = fixed::FromInt(1);
 
-        CFixedVector2D initialPos = cmpPosition->GetPosition2D();
+    bool wasObstructed = false;
 
-        // If we're chasing a potentially-moving unit and are currently close
-        // enough to its current position, and we can head in a straight line
-        // to it, then throw away our current path and go straight to it
-        if (m_PathState == PATHSTATE_FOLLOWING)
-            TryGoingStraightToTargetEntity(initialPos);
+    // We want to move (at most) m_Speed*dt units from pos towards the next waypoint
 
-        // Keep track of the current unit's position during the update
-        CFixedVector2D pos = initialPos;
+    fixed timeLeft = dt;
 
-        // If in formation, run to keep up; otherwise just walk
-        fixed basicSpeed;
-        if (IsFormationMember())
-            basicSpeed = GetRunSpeed();
-        else
-            basicSpeed = m_Speed; // (typically but not always WalkSpeed)
+    while (timeLeft > fixed::Zero())
+    {
+        // If we ran out of path, we have to stop
+        if (!HasValidPath())
+            break;
 
-        // Find the speed factor of the underlying terrain
-        // (We only care about the tile we start on - it doesn't matter if we're moving
-        // partially onto a much slower/faster tile)
-        // TODO: Terrain-dependent speeds are not currently supported
-        fixed terrainSpeed = fixed::FromInt(1);
+        CFixedVector2D target;
+        target = CFixedVector2D(m_Path.m_Waypoints.back().x, m_Path.m_Waypoints.back().z);
 
-        fixed maxSpeed = basicSpeed.Multiply(terrainSpeed);
+        CFixedVector2D offset = target - pos;
+        fixed offsetLength = offset.Length();
+        // Work out how far we can travel in timeLeft
+        fixed maxdist = m_Speed.Multiply(timeLeft);
 
-        bool wasObstructed = false;
+        CFixedVector2D destination;
+        if (offsetLength <= maxdist)
+            destination = target;
+        else
+        {
+            offset.Normalize(maxdist);
+            destination = pos + offset;
+        }
 
-        // We want to move (at most) maxSpeed*dt units from pos towards the next waypoint
+        // TODO: try moving as much as we can still?
+        // TODO: get more information about what blocked us.
+        if (cmpPathfinder->CheckMovement(GetObstructionFilter(), pos.X, pos.Y, target.X, target.Y, m_Clearance, m_PassClass))
+        {
+            pos = destination;
 
-        fixed timeLeft = dt;
-        fixed zero = fixed::Zero();
+            timeLeft = (timeLeft.Multiply(m_Speed) - offsetLength) / m_Speed;
 
-        while (timeLeft > zero)
+            if (destination == target)
+                m_Path.m_Waypoints.pop_back();
+            continue;
+        }
+        else
         {
-            // If we ran out of path, we have to stop
-            if (m_ShortPath.m_Waypoints.empty() && m_LongPath.m_Waypoints.empty())
-                break;
-
-            CFixedVector2D target;
-            if (m_ShortPath.m_Waypoints.empty())
-                target = CFixedVector2D(m_LongPath.m_Waypoints.back().x, m_LongPath.m_Waypoints.back().z);
-            else
-                target = CFixedVector2D(m_ShortPath.m_Waypoints.back().x, m_ShortPath.m_Waypoints.back().z);
+            // Error - path was obstructed
+            wasObstructed = true;
+            break;
+        }
+    }
 
-            CFixedVector2D offset = target - pos;
+    if (!m_StartedMoving && wasObstructed)
+        // If this is the turn we start moving, and we're already obstructed,
+        // fail the move entirely to avoid weirdness.
+        // (we would need to send a "move started" and a "move failed" message in the same turn)
+        pos = initialPos;
 
-            // Work out how far we can travel in timeLeft
-            fixed maxdist = maxSpeed.Multiply(timeLeft);
+    // Update the Position component after our movement (if we actually moved anywhere)
+    if (pos != initialPos)
+    {
+        CFixedVector2D offset = pos - initialPos;
 
-            // If the target is close, we can move there directly
-            fixed offsetLength = offset.Length();
-            if (offsetLength <= maxdist)
-            {
-                if (cmpPathfinder->CheckMovement(GetObstructionFilter(), pos.X, pos.Y, target.X, target.Y, m_Clearance, m_PassClass))
-                {
-                    pos = target;
-
-                    // Spend the rest of the time heading towards the next waypoint
-                    timeLeft = timeLeft - (offsetLength / maxSpeed);
-
-                    if (m_ShortPath.m_Waypoints.empty())
-                        m_LongPath.m_Waypoints.pop_back();
-                    else
-                        m_ShortPath.m_Waypoints.pop_back();
-
-                    continue;
-                }
-                else
-                {
-                    // Error - path was obstructed
-                    wasObstructed = true;
-                    break;
-                }
-            }
-            else
-            {
-                // Not close enough, so just move in the right direction
-                offset.Normalize(maxdist);
-                target = pos + offset;
+        // Face towards the target
+        entity_angle_t angle = atan2_approx(offset.X, offset.Y);
+        cmpPosition->MoveAndTurnTo(pos.X,pos.Y, angle);
 
-                if (cmpPathfinder->CheckMovement(GetObstructionFilter(), pos.X, pos.Y, target.X, target.Y, m_Clearance, m_PassClass))
-                    pos = target;
-                else
-                    wasObstructed = true; // Error - path was obstructed
+        // Calculate the mean speed over this past turn.
+        m_ActualSpeed = cmpPosition->GetDistanceTravelled() / dt;
 
-                break;
-            }
-        }
+        // tell other components and visual actor we are moving.
+        if (!m_StartedMoving)
+            MoveStarted();
 
-        // Update the Position component after our movement (if we actually moved anywhere)
-        if (pos != initialPos)
+        // Check if we are at our destination
+        // since we're already checking in the general case at the beginning of this function,
+        // no need to do this outside this if block.
+        if (ShouldConsiderOurselvesAtDestination())
         {
-            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;
+            CompleteMove();
+            return;
         }
 
-        if (wasObstructed)
+        if (!wasObstructed)
         {
-            // Oops, we hit something (very likely another unit).
-            // This is when we might easily get stuck wrongly.
-
-            // check if we've arrived.
-            if (ShouldConsiderOurselvesAtDestination(pos))
-                return;
-
-            // If we still have long waypoints, try and compute a short path
-            // This will get us around units, amongst others.
-            // However in some cases a long waypoint will be in located in the obstruction of
-            // an idle unit. In that case, we need to scrap that waypoint or we might never be able to reach it.
-            // I am not sure why this happens but the following code seems to work.
-            if (!m_LongPath.m_Waypoints.empty())
-            {
-                CmpPtr<ICmpObstructionManager> cmpObstructionManager(GetSystemEntity());
-                if (cmpObstructionManager)
-                {
-                    // create a fake obstruction to represent our waypoint.
-                    ICmpObstructionManager::ObstructionSquare square;
-                    square.hh = m_Clearance;
-                    square.hw = m_Clearance;
-                    square.u = CFixedVector2D(entity_pos_t::FromInt(1),entity_pos_t::FromInt(0));
-                    square.v = CFixedVector2D(entity_pos_t::FromInt(0),entity_pos_t::FromInt(1));
-                    square.x = m_LongPath.m_Waypoints.back().x;
-                    square.z = m_LongPath.m_Waypoints.back().z;
-                    std::vector<entity_id_t> unitOnGoal;
-                    // don't ignore moving units as those might be units like us, ie not really moving.
-                    cmpObstructionManager->GetUnitsOnObstruction(square, unitOnGoal, GetObstructionFilter(), true);
-                    if (!unitOnGoal.empty())
-                        m_LongPath.m_Waypoints.pop_back();
-                }
-                if (!m_LongPath.m_Waypoints.empty())
-                {
-                    PathGoal goal;
-                    if (m_LongPath.m_Waypoints.size() > 1 || m_FinalGoal.DistanceToPoint(pos) > LONG_PATH_MIN_DIST)
-                        goal = { PathGoal::POINT, m_LongPath.m_Waypoints.back().x, m_LongPath.m_Waypoints.back().z };
-                    else
-                    {
-                        UpdateFinalGoal();
-                        goal = m_FinalGoal;
-                        m_LongPath.m_Waypoints.clear();
-                        CFixedVector2D target = goal.NearestPointOnGoal(pos);
-                        m_LongPath.m_Waypoints.emplace_back(Waypoint{ target.X, target.Y });
-                    }
-                    RequestShortPath(pos, goal, true);
-                    m_PathState = PATHSTATE_WAITING_REQUESTING_SHORT;
-                    return;
-                }
-            }
-            // Else, just entirely recompute
-            UpdateFinalGoal();
-            BeginPathing(pos, m_FinalGoal);
-
-            // potential TODO: We could switch the short-range pathfinder for something else entirely.
+            // everything is going smoothly, return.
+            m_Tries = 0;
+            m_WaitingTurns = 0;
             return;
         }
+    }
 
-        // We successfully moved along our path, until running out of
-        // waypoints or time.
+    // tell relevant components we have paused if necessary
+    if (m_StartedMoving)
+        MovePaused();
 
-        if (m_PathState == PATHSTATE_FOLLOWING)
-        {
-            // If we're not currently computing any new paths:
-            if (m_LongPath.m_Waypoints.empty() && m_ShortPath.m_Waypoints.empty())
-            {
-                if (IsFormationMember())
-                {
-                    // We've reached our assigned position. If the controller
-                    // is idle, send a notification in case it should disband,
-                    // otherwise continue following the formation next turn.
-                    CmpPtr<ICmpUnitMotion> cmpUnitMotion(GetSimContext(), m_TargetEntity);
-                    if (cmpUnitMotion && !cmpUnitMotion->IsMoving())
-                    {
-                        CmpPtr<ICmpObstruction> cmpObstruction(GetEntityHandle());
-                        if (cmpObstruction)
-                            cmpObstruction->SetMovingFlag(false);
-
-                        m_Moving = false;
-                        CMessageMotionChanged msg(false, false);
-                        GetSimContext().GetComponentManager().PostMessage(GetEntityId(), msg);
-                    }
-                }
-                else
-                {
-                    // check if target was reached in case of a moving target
-                    CmpPtr<ICmpUnitMotion> cmpUnitMotion(GetSimContext(), m_TargetEntity);
-                    if (cmpUnitMotion && cmpUnitMotion->IsMoving() &&
-                        MoveToTargetRange(m_TargetEntity, m_TargetMinRange, m_TargetMaxRange))
-                        return;
-
-                    // Not in formation, so just finish moving
-                    StopMoving();
-                    m_State = STATE_IDLE;
-                    MoveSucceeded();
-
-                    if (m_FacePointAfterMove)
-                        FaceTowardsPointFromPos(pos, m_FinalGoal.x, m_FinalGoal.z);
-                    // TODO: if the goal was a square building, we ought to point towards the
-                    // nearest point on the square, not towards its center
-                }
-            }
+    // Oops, we've had a problem. Either we were obstructed, or we ran out of path (but still have a goal).
+    // Handle it.
+    // Failure to handle it will result in stuckness and players complaining.
 
-            // If we have a target entity, and we're not miles away from the end of
-            // our current path, and the target moved enough, then recompute our
-            // whole path
-            if (IsFormationMember())
-                CheckTargetMovement(pos, CHECK_TARGET_MOVEMENT_MIN_DELTA_FORMATION);
-            else
-                CheckTargetMovement(pos, CHECK_TARGET_MOVEMENT_MIN_DELTA);
-        }
-    }
+    if (m_ExpectedPathTicket != 0)
+        // wait until we get our path to see where that leads us.
+        return;
+
+    // give us some turns to recover.
+    // TODO: only do this if we ran into a moving unit and not something else, because something else won't move
+    if (m_WaitingTurns == 0)
+    {
+        if (HasValidPath())
+            m_WaitingTurns = MAX_PATH_REATTEMPS + 1;
+        else
+            m_WaitingTurns = 3;
     }
-}
 
-bool CCmpUnitMotion::ComputeTargetPosition(CFixedVector2D& out)
-{
-    if (m_TargetEntity == INVALID_ENTITY)
-        return false;
+    --m_WaitingTurns;
 
-    CmpPtr<ICmpPosition> cmpPosition(GetSimContext(), m_TargetEntity);
-    if (!cmpPosition || !cmpPosition->IsInWorld())
-        return false;
+    // Try again next turn, no changes
+    if (m_WaitingTurns >= MAX_PATH_REATTEMPS)
+        return;
 
-    if (m_TargetOffset.IsZero())
+    // already waited one turn, no changes, so try computing a short path.
+    if (m_WaitingTurns >= 3)
     {
-        // No offset, just return the position directly
-        out = cmpPosition->GetPosition2D();
+        PathGoal goal;
+        if (m_Path.m_Waypoints.empty())
+            goal = { PathGoal::POINT, m_FinalGoal.X(), m_FinalGoal.Z() };
+        else
+        {
+            goal = { PathGoal::POINT, m_Path.m_Waypoints.back().x, m_Path.m_Waypoints.back().z };
+            m_Path.m_Waypoints.pop_back();
+        }
+        RequestShortPath(pos, goal, true);
+        return;
     }
-    else
+
+    // Last resort, compute a long path
+    if (m_WaitingTurns == 2)
     {
-        // There is an offset, so compute it relative to orientation
-        entity_angle_t angle = cmpPosition->GetRotation().Y;
-        CFixedVector2D offset = m_TargetOffset.Rotate(angle);
-        out = cmpPosition->GetPosition2D() + offset;
+        PathGoal goal;
+        if (m_Path.m_Waypoints.empty())
+            goal = { PathGoal::POINT, m_FinalGoal.X(), m_FinalGoal.Z() };
+        else
+        {
+            goal = { PathGoal::POINT, m_Path.m_Waypoints.back().x, m_Path.m_Waypoints.back().z };
+            m_Path.m_Waypoints.pop_back();
+        }
+        RequestLongPath(pos, goal);
+        return;
     }
-    return true;
-}
 
-bool CCmpUnitMotion::TryGoingStraightToGoalPoint(const CFixedVector2D& from)
-{
-    // Make sure the goal is a point (and not a point-like target like a formation controller)
-    if (m_FinalGoal.type != PathGoal::POINT || m_TargetEntity != INVALID_ENTITY)
-        return false;
 
-    // Fail if the goal is too far away
-    CFixedVector2D goalPos(m_FinalGoal.x, m_FinalGoal.z);
-    if ((goalPos - from).CompareLength(DIRECT_PATH_RANGE) > 0)
-        return false;
+    // m_waitingTurns == 1 here
 
-    CmpPtr<ICmpPathfinder> cmpPathfinder(GetSystemEntity());
-    if (!cmpPathfinder)
-        return false;
+    // we tried getting a renewed path and still got stuck
+    if (m_AbortIfStuck == 0)
+    {
+        MoveFailed();
+        return;
+    }
 
-    // Check if there's any collisions on that route
-    if (!cmpPathfinder->CheckMovement(GetObstructionFilter(), from.X, from.Y, goalPos.X, goalPos.Y, m_Clearance, m_PassClass))
-        return false;
+    --m_AbortIfStuck;
 
-    // That route is okay, so update our path
-    m_LongPath.m_Waypoints.clear();
-    m_ShortPath.m_Waypoints.clear();
-    m_ShortPath.m_Waypoints.emplace_back(Waypoint{ goalPos.X, goalPos.Y });
+    // Recompute a new path, but wait a dozen turns.
+    m_WaitingTurns = 12 + MAX_PATH_REATTEMPS;
 
-    return true;
+    return;
 }
 
-bool CCmpUnitMotion::TryGoingStraightToTargetEntity(const CFixedVector2D& from)
+// TODO: this should care about target movement
+bool CCmpUnitMotion::CheckTargetMovement(const CFixedVector2D& from, entity_pos_t minDelta)
 {
-    CFixedVector2D targetPos;
-    if (!ComputeTargetPosition(targetPos))
+    if (!m_FinalGoal.TargetIsEntity())
         return false;
 
-    // Fail if the target is too far away
-    if ((targetPos - from).CompareLength(DIRECT_PATH_RANGE) > 0)
-        return false;
+    if (!HasValidPath())
+        return true;
 
-    CmpPtr<ICmpPathfinder> cmpPathfinder(GetSystemEntity());
-    if (!cmpPathfinder)
-        return false;
-
-    // Move the goal to match the target entity's new position
-    PathGoal goal = m_FinalGoal;
-    goal.x = targetPos.X;
-    goal.z = targetPos.Y;
-    // (we ignore changes to the target's rotation, since only buildings are
-    // square and buildings don't move)
-
-    // Find the point on the goal shape that we should head towards
-    CFixedVector2D goalPos = goal.NearestPointOnGoal(from);
-
-    // Check if there's any collisions on that route
-    if (!cmpPathfinder->CheckMovement(GetObstructionFilter(true), from.X, from.Y, goalPos.X, goalPos.Y, m_Clearance, m_PassClass))
-        return false;
-
-    // That route is okay, so update our path
-    m_FinalGoal = goal;
-    m_LongPath.m_Waypoints.clear();
-    m_ShortPath.m_Waypoints.clear();
-    m_ShortPath.m_Waypoints.emplace_back(Waypoint{ goalPos.X, goalPos.Y });
-
-    return true;
-}
+    // Fail unless the target has moved enough
+    CFixedVector2D oldTargetPos = CFixedVector2D(m_Path.m_Waypoints[0].x,m_Path.m_Waypoints[0].z);
 
-bool CCmpUnitMotion::CheckTargetMovement(const CFixedVector2D& from, entity_pos_t minDelta)
-{
-    CFixedVector2D targetPos;
-    if (!ComputeTargetPosition(targetPos))
+    if ((m_FinalGoal.Pos() - oldTargetPos).CompareLength(minDelta) < 0)
         return false;
 
-    // Fail unless the target has moved enough
-    CFixedVector2D oldTargetPos(m_FinalGoal.x, m_FinalGoal.z);
-    if ((targetPos - oldTargetPos).CompareLength(minDelta) < 0)
-        return false;
 
     CmpPtr<ICmpPosition> cmpPosition(GetEntityHandle());
     if (!cmpPosition || !cmpPosition->IsInWorld())
         return false;
     CFixedVector2D pos = cmpPosition->GetPosition2D();
     CFixedVector2D oldDir = (oldTargetPos - pos);
-    CFixedVector2D newDir = (targetPos - pos);
+    CFixedVector2D newDir = (m_FinalGoal.Pos() - pos);
     oldDir.Normalize();
     newDir.Normalize();
 
     // Fail unless we're close enough to the target to care about its movement
     // and the angle between the (straight-line) directions of the previous and new target positions is small
-    if (oldDir.Dot(newDir) > CHECK_TARGET_MOVEMENT_MIN_COS && !PathIsShort(m_LongPath, from, CHECK_TARGET_MOVEMENT_AT_MAX_DIST))
+    if (oldDir.Dot(newDir) > CHECK_TARGET_MOVEMENT_MIN_COS && !PathIsShort(m_Path, from, CHECK_TARGET_MOVEMENT_AT_MAX_DIST))
         return false;
 
     // Fail if the target is no longer visible to this entity's owner
@@ -1183 +980 @@
     if (cmpOwnership)
     {
         CmpPtr<ICmpRangeManager> cmpRangeManager(GetSystemEntity());
-        if (cmpRangeManager && cmpRangeManager->GetLosVisibility(m_TargetEntity, cmpOwnership->GetOwner()) == ICmpRangeManager::VIS_HIDDEN)
+        if (cmpRangeManager && cmpRangeManager->GetLosVisibility(m_FinalGoal.GetEntity(), cmpOwnership->GetOwner()) == ICmpRangeManager::VIS_HIDDEN)
             return false;
     }
 
     // The target moved and we need to update our current path;
-    // change the goal here and expect our caller to start the path request
-    m_FinalGoal.x = targetPos.X;
-    m_FinalGoal.z = targetPos.Y;
-    RequestLongPath(from, m_FinalGoal);
-    m_PathState = PATHSTATE_FOLLOWING_REQUESTING_LONG;
+    // Expect our caller to recompute
+    // Dump our current path.
+    m_Path.m_Waypoints.clear();
 
     return true;
 }
 
-void CCmpUnitMotion::UpdateFinalGoal()
+// TODO: ought to be cleverer here.
+// In particular maybe we should support some "margin" for error.
+bool CCmpUnitMotion::ShouldConsiderOurselvesAtDestination()
 {
-    if (m_TargetEntity == INVALID_ENTITY)
-        return;
-    CmpPtr<ICmpUnitMotion> cmpUnitMotion(GetSimContext(), m_TargetEntity);
-    if (!cmpUnitMotion)
-        return;
-    if (IsFormationMember())
-        return;
-    CFixedVector2D targetPos;
-    if (!ComputeTargetPosition(targetPos))
-        return;
-    m_FinalGoal.x = targetPos.X;
-    m_FinalGoal.z = targetPos.Y;
-}
-
-bool CCmpUnitMotion::ShouldConsiderOurselvesAtDestination(const CFixedVector2D& from)
-{
-    if (m_TargetEntity != INVALID_ENTITY || m_FinalGoal.DistanceToPoint(from) > SHORT_PATH_GOAL_RADIUS)
-        return false;
-
-    StopMoving();
-    MoveSucceeded();
-
-    if (m_FacePointAfterMove)
-        FaceTowardsPointFromPos(from, m_FinalGoal.x, m_FinalGoal.z);
-    return true;
+    if (m_FinalGoal.TargetIsEntity())
+        return IsInTargetRange(m_FinalGoal.GetEntity(), m_FinalGoal.MinRange(), m_FinalGoal.MaxRange());
+    else
+        return IsInPointRange(m_FinalGoal.X(),m_FinalGoal.Z(), m_FinalGoal.MinRange(), m_FinalGoal.MaxRange());
 }
 
 bool CCmpUnitMotion::PathIsShort(const WaypointPath& path, const CFixedVector2D& from, entity_pos_t minDistance) const
@@ -1275 +1051 @@
 
 ControlGroupMovementObstructionFilter CCmpUnitMotion::GetObstructionFilter(bool noTarget) const
 {
-    entity_id_t group = noTarget ? m_TargetEntity : GetGroup();
-    return ControlGroupMovementObstructionFilter(ShouldAvoidMovingUnits(), group);
+    entity_id_t group = noTarget ? m_FinalGoal.GetEntity() : GetGroup();
+    // TODO: if we sometimes want to consider moving units, change here.
+    return ControlGroupMovementObstructionFilter(false, group);
 }
 
-
-
-void CCmpUnitMotion::BeginPathing(const CFixedVector2D& from, const PathGoal& goal)
+// TODO: this should be improved, it's a little limited
+// EG use of hierarchical pathfinder,…
+// also it should probably make the goal passable directly, to avoid conflict with the paths returned.
+void CCmpUnitMotion::RequestNewPath()
 {
-    // reset our state for sanity.
-    m_ExpectedPathTicket = 0;
+    ENSURE(m_ExpectedPathTicket == 0);
 
-    CmpPtr<ICmpObstruction> cmpObstruction(GetEntityHandle());
-    if (cmpObstruction)
-        cmpObstruction->SetMovingFlag(false);
+    CmpPtr<ICmpPosition> cmpPosition(GetEntityHandle());
+    if (!cmpPosition)
+        return;
 
-    m_Moving = false;
+    // dump current path
+    m_Path.m_Waypoints.clear();
 
-    m_PathState = PATHSTATE_NONE;
+    CFixedVector2D position = cmpPosition->GetPosition2D();
 
 #if DISABLE_PATHFINDER
     {
         CmpPtr<ICmpPathfinder> cmpPathfinder (GetSimContext(), SYSTEM_ENTITY);
-        CFixedVector2D goalPos = m_FinalGoal.NearestPointOnGoal(from);
+        CFixedVector2D goalPos = m_FinalGoal.Goal().NearestPointOnGoal(position);
         m_LongPath.m_Waypoints.clear();
         m_ShortPath.m_Waypoints.clear();
         m_ShortPath.m_Waypoints.emplace_back(Waypoint{ goalPos.X, goalPos.Y });
-        m_PathState = PATHSTATE_FOLLOWING;
         return;
     }
 #endif
 
-    // If we're aiming at a target entity and it's close and we can reach
-    // it in a straight line, then we'll just go along the straight line
-    // instead of computing a path.
-    if (TryGoingStraightToTargetEntity(from))
-    {
-        if (!HasValidPath())
-            StartSucceeded();
-        m_PathState = PATHSTATE_FOLLOWING;
-        return;
-    }
-
-    // Same thing applies to non-entity points
-    if (TryGoingStraightToGoalPoint(from))
-    {
-        if (!HasValidPath())
-            StartSucceeded();
-        m_PathState = PATHSTATE_FOLLOWING;
-        return;
-    }
-
-    // Otherwise we need to compute a path.
-
     // If it's close then just do a short path, not a long path
     // TODO: If it's close on the opposite side of a river then we really
     // need a long path, so we shouldn't simply check linear distance
     // the check is arbitrary but should be a reasonably small distance.
-    if (goal.DistanceToPoint(from) < LONG_PATH_MIN_DIST)
-    {
-        // add our final goal as a long range waypoint so we don't forget
-        // where we are going if the short-range pathfinder returns
-        // an aborted path.
-        m_LongPath.m_Waypoints.clear();
-        CFixedVector2D target = m_FinalGoal.NearestPointOnGoal(from);
-        m_LongPath.m_Waypoints.emplace_back(Waypoint{ target.X, target.Y });
-        m_PathState = PATHSTATE_WAITING_REQUESTING_SHORT;
-        RequestShortPath(from, goal, true);
-    }
+    // Maybe use PathIsShort?
+    if (m_FinalGoal.Goal().DistanceToPoint(position) < LONG_PATH_MIN_DIST)
+        RequestShortPath(position, m_FinalGoal.Goal(), true);
     else
-    {
-        m_PathState = PATHSTATE_WAITING_REQUESTING_LONG;
-        RequestLongPath(from, goal);
-    }
+        RequestLongPath(position, m_FinalGoal.Goal());
 }
 
 void CCmpUnitMotion::RequestLongPath(const CFixedVector2D& from, const PathGoal& goal)
@@ -1391 +1135 @@
 {
     PROFILE("MoveToPointRange");
 
+    DiscardMove();
+
     CmpPtr<ICmpPosition> cmpPosition(GetEntityHandle());
     if (!cmpPosition || !cmpPosition->IsInWorld())
         return false;
@@ -1442 +1188 @@
         }
     }
 
-    m_State = STATE_INDIVIDUAL_PATH;
-    m_TargetEntity = target;
-    m_TargetOffset = CFixedVector2D();
-    m_TargetMinRange = minRange;
-    m_TargetMaxRange = maxRange;
-    m_FinalGoal = goal;
-    m_Tries = 0;
+    if (target == INVALID_ENTITY)
+        m_FinalGoal = SMotionGoal(goal, minRange, maxRange);
+    else
+        m_FinalGoal = SMotionGoal(GetSimContext(), target, goal, minRange, maxRange);
 
-    BeginPathing(pos, goal);
+    RequestNewPath();
 
     return true;
 }
@@ -1463 +1206 @@
 
     CFixedVector2D pos = cmpPosition->GetPosition2D();
 
-    bool hasObstruction = false;
-    CmpPtr<ICmpObstructionManager> cmpObstructionManager(GetSystemEntity());
-    ICmpObstructionManager::ObstructionSquare obstruction;
-//TODO  if (cmpObstructionManager)
-//      hasObstruction = cmpObstructionManager->FindMostImportantObstruction(GetObstructionFilter(), x, z, m_Radius, obstruction);
-
-    if (minRange.IsZero() && maxRange.IsZero() && hasObstruction)
-    {
-        // Handle the non-ranged mode:
-        CFixedVector2D halfSize(obstruction.hw, obstruction.hh);
-        entity_pos_t distance = Geometry::DistanceToSquare(pos - CFixedVector2D(obstruction.x, obstruction.z), obstruction.u, obstruction.v, halfSize);
-
-        // See if we're too close to the target square
-        if (distance < minRange)
-            return false;
-
-        // See if we're close enough to the target square
-        if (maxRange < entity_pos_t::Zero() || distance <= maxRange)
-            return true;
+    entity_pos_t distance = (pos - CFixedVector2D(x, z)).Length();
 
+    if (distance < minRange)
+        return false;
+    else if (maxRange >= entity_pos_t::Zero() && distance > maxRange)
         return false;
-    }
     else
-    {
-        entity_pos_t distance = (pos - CFixedVector2D(x, z)).Length();
-
-        if (distance < minRange)
-            return false;
-        else if (maxRange >= entity_pos_t::Zero() && distance > maxRange)
-            return false;
-        else
-            return true;
-    }
+        return true;
 }
 
 bool CCmpUnitMotion::ShouldTreatTargetAsCircle(entity_pos_t range, entity_pos_t circleRadius) const
@@ -1512 +1230 @@
 {
     PROFILE("MoveToTargetRange");
 
+    DiscardMove();
+
     CmpPtr<ICmpPosition> cmpPosition(GetEntityHandle());
     if (!cmpPosition || !cmpPosition->IsInWorld())
         return false;
@@ -1655 +1375 @@
         }
     }
 
-    m_State = STATE_INDIVIDUAL_PATH;
-    m_TargetEntity = target;
-    m_TargetOffset = CFixedVector2D();
-    m_TargetMinRange = minRange;
-    m_TargetMaxRange = maxRange;
-    m_FinalGoal = goal;
-    m_Tries = 0;
+    if (target == INVALID_ENTITY)
+        m_FinalGoal = SMotionGoal(goal, minRange, maxRange);
+    else
+        m_FinalGoal = SMotionGoal(GetSimContext(), target, goal, minRange, maxRange);
 
-    BeginPathing(pos, goal);
+    RequestNewPath();
 
     return true;
 }
@@ -1738 +1455 @@
     }
 }
 
-void CCmpUnitMotion::MoveToFormationOffset(entity_id_t target, entity_pos_t x, entity_pos_t z)
-{
-    CmpPtr<ICmpPosition> cmpPosition(GetSimContext(), target);
-    if (!cmpPosition || !cmpPosition->IsInWorld())
-        return;
-
-    CFixedVector2D pos = cmpPosition->GetPosition2D();
-
-    PathGoal goal;
-    goal.type = PathGoal::POINT;
-    goal.x = pos.X;
-    goal.z = pos.Y;
-
-    m_State = STATE_FORMATIONMEMBER_PATH;
-    m_TargetEntity = target;
-    m_TargetOffset = CFixedVector2D(x, z);
-    m_TargetMinRange = entity_pos_t::Zero();
-    m_TargetMaxRange = entity_pos_t::Zero();
-    m_FinalGoal = goal;
-    m_Tries = 0;
-
-    BeginPathing(pos, goal);
-}
-
-
-
-
 
 void CCmpUnitMotion::RenderPath(const WaypointPath& path, std::vector<SOverlayLine>& lines, CColor color)
 {
@@ -1800 +1490 @@
     if (!m_DebugOverlayEnabled)
         return;
 
-    RenderPath(m_LongPath, m_DebugOverlayLongPathLines, OVERLAY_COLOR_LONG_PATH);
-    RenderPath(m_ShortPath, m_DebugOverlayShortPathLines, OVERLAY_COLOR_SHORT_PATH);
+    RenderPath(m_Path, m_DebugOverlayLongPathLines, OVERLAY_COLOR_LONG_PATH);
 
     for (size_t i = 0; i < m_DebugOverlayLongPathLines.size(); ++i)
         collector.Submit(&m_DebugOverlayLongPathLines[i]);

source/simulation2/components/CCmpVisualActor.cpp

@@ -71 +71 @@
 
     fixed m_R, m_G, m_B; // shading color
 
-    std::map<std::string, std::string> m_AnimOverride;
-
     // Current animation state
-    fixed m_AnimRunThreshold; // if non-zero this is the special walk/run mode
     std::string m_AnimName;
     bool m_AnimOnce;
     fixed m_AnimSpeed;
@@ -83 +80 @@
     fixed m_AnimSyncRepeatTime; // 0.0 if not synced
     fixed m_AnimSyncOffsetTime;
 
+    std::string m_MovingPrefix;
+    fixed m_MovingSpeed;
+    bool m_MovingNow, m_MovingLastTurn;
+
     std::map<CStr, CStr> m_VariantSelections;
 
     u32 m_Seed; // seed used for random variations
@@ -206 +207 @@
 
         InitModel(paramNode);
 
+        m_MovingLastTurn = m_MovingNow = false;
+
         SelectAnimation("idle", false, fixed::FromInt(1), L"");
     }
 
@@ -225 +228 @@
         serialize.NumberFixed_Unbounded("g", m_G);
         serialize.NumberFixed_Unbounded("b", m_B);
 
-        SerializeMap<SerializeString, SerializeString>()(serialize, "anim overrides", m_AnimOverride);
-
-        serialize.NumberFixed_Unbounded("anim run threshold", m_AnimRunThreshold);
         serialize.StringASCII("anim name", m_AnimName, 0, 256);
         serialize.Bool("anim once", m_AnimOnce);
         serialize.NumberFixed_Unbounded("anim speed", m_AnimSpeed);
@@ -236 +236 @@
         serialize.NumberFixed_Unbounded("anim sync repeat time", m_AnimSyncRepeatTime);
         serialize.NumberFixed_Unbounded("anim sync offset time", m_AnimSyncOffsetTime);
 
+        serialize.Bool("moving now", m_MovingNow);
+        serialize.Bool("moving last turn", m_MovingLastTurn);
+
         SerializeMap<SerializeString, SerializeString>()(serialize, "variation", m_VariantSelections);
 
         serialize.NumberU32_Unbounded("seed", m_Seed);
@@ -423 +426 @@
 
     virtual void SelectAnimation(const std::string& name, bool once, fixed speed, const std::wstring& soundgroup)
     {
-        m_AnimRunThreshold = fixed::Zero();
         m_AnimName = name;
         m_AnimOnce = once;
         m_AnimSpeed = speed;
@@ -432 +434 @@
         m_AnimSyncRepeatTime = fixed::Zero();
         m_AnimSyncOffsetTime = fixed::Zero();
 
-        SetVariant("animation", m_AnimName);
-
-        if (m_Unit && m_Unit->GetAnimation())
-            m_Unit->GetAnimation()->SetAnimationState(m_AnimName, m_AnimOnce, m_AnimSpeed.ToFloat(), m_AnimDesync.ToFloat(), m_SoundGroup.c_str());
-    }
+        // TODO: change this once we support walk/run-anims
+        std::string animName = name;
+        /*if (!m_MovingPrefix.empty() && m_AnimName != "idle")
+            animName = m_MovingPrefix + "-" + m_AnimName;
+        else */if (!m_MovingPrefix.empty())
+            animName = m_MovingPrefix;
 
-    virtual void ReplaceMoveAnimation(const std::string& name, const std::string& replace)
-    {
-        m_AnimOverride[name] = replace;
-    }
+        SetVariant("animation", animName);
 
-    virtual void ResetMoveAnimation(const std::string& name)
-    {
-        std::map<std::string, std::string>::const_iterator it = m_AnimOverride.find(name);
-        if (it != m_AnimOverride.end())
-            m_AnimOverride.erase(name);
+        if (m_Unit && m_Unit->GetAnimation())
+            m_Unit->GetAnimation()->SetAnimationState(animName, m_AnimOnce, m_MovingSpeed.Multiply(m_AnimSpeed).ToFloat(), m_AnimDesync.ToFloat(), m_SoundGroup.c_str());
     }
 
-    virtual void SelectMovementAnimation(fixed runThreshold)
+    virtual void SetMoving(bool moving)
     {
-        SelectAnimation("walk", false, fixed::FromFloat(1.f), L"");
-        m_AnimRunThreshold = runThreshold;
+        m_MovingNow = moving;
     }
 
     virtual void SetAnimationSyncRepeat(fixed repeattime)
@@ -751 +747 @@
     // far less hacky. We should also take into account the speed when the animation is different
     // from the "special movement mode" walking animation.
 
-    // If we're not in the special movement mode, nothing to do.
-    if (m_AnimRunThreshold.IsZero())
-        return;
+    //if (!m_MovingNow && !m_MovingLastTurn)
+    //  return;
 
     CmpPtr<ICmpPosition> cmpPosition(GetEntityHandle());
     if (!cmpPosition || !cmpPosition->IsInWorld())
@@ -763 +758 @@
     if (!cmpUnitMotion)
         return;
 
-    fixed speed = cmpUnitMotion->GetCurrentSpeed();
-    std::string name;
+    // TODO: change this to make us run as fast but stop earlier instead of this hack.
+    // Probably should subscribe dynamically too.
+    fixed speed = cmpUnitMotion->GetActualSpeed();
+    std::string prefix;
 
-    if (speed.IsZero())
+    if (!m_MovingNow || speed.IsZero())
     {
         speed = fixed::FromFloat(1.f);
-        name = "idle";
+        prefix = "";
     }
     else
-        name = speed < m_AnimRunThreshold ? "walk" : "run";
+        prefix = cmpUnitMotion->GetSpeedRatio() <= fixed::FromInt(1) ? "walk" : "run";
+
+    m_MovingPrefix = prefix;
+    m_MovingSpeed = speed;
 
-    std::map<std::string, std::string>::const_iterator it = m_AnimOverride.find(name);
-    if (it != m_AnimOverride.end())
-        name = it->second;
+    SelectAnimation(m_AnimName, m_AnimOnce, m_AnimSpeed, m_SoundGroup);
 
-    // Selecting the animation is going to reset the anim run threshold, so save it
-    fixed runThreshold = m_AnimRunThreshold;
-    SelectAnimation(name, false, speed, L"");
-    m_AnimRunThreshold = runThreshold;
+    m_MovingLastTurn = m_MovingNow;
 }

source/simulation2/components/ICmpUnitMotion.cpp

@@ -27 +27 @@
 DEFINE_INTERFACE_METHOD_4("IsInPointRange", bool, ICmpUnitMotion, IsInPointRange, entity_pos_t, entity_pos_t, entity_pos_t, entity_pos_t)
 DEFINE_INTERFACE_METHOD_3("IsInTargetRange", bool, ICmpUnitMotion, IsInTargetRange, entity_id_t, entity_pos_t, entity_pos_t)
 DEFINE_INTERFACE_METHOD_3("MoveToTargetRange", bool, ICmpUnitMotion, MoveToTargetRange, entity_id_t, entity_pos_t, entity_pos_t)
-DEFINE_INTERFACE_METHOD_3("MoveToFormationOffset", void, ICmpUnitMotion, MoveToFormationOffset, entity_id_t, entity_pos_t, entity_pos_t)
 DEFINE_INTERFACE_METHOD_2("FaceTowardsPoint", void, ICmpUnitMotion, FaceTowardsPoint, entity_pos_t, entity_pos_t)
-DEFINE_INTERFACE_METHOD_0("StopMoving", void, ICmpUnitMotion, StopMoving)
-DEFINE_INTERFACE_METHOD_0("GetCurrentSpeed", fixed, ICmpUnitMotion, GetCurrentSpeed)
+DEFINE_INTERFACE_METHOD_1("SetAbortIfStuck", void, ICmpUnitMotion, SetAbortIfStuck, u8)
+DEFINE_INTERFACE_METHOD_0("DiscardMove", void, ICmpUnitMotion, DiscardMove)
+DEFINE_INTERFACE_METHOD_0("CompleteMove", void, ICmpUnitMotion, CompleteMove)
+DEFINE_INTERFACE_METHOD_0("GetActualSpeed", fixed, ICmpUnitMotion, GetActualSpeed)
+DEFINE_INTERFACE_METHOD_0("GetTopSpeedRatio", fixed, ICmpUnitMotion, GetTopSpeedRatio)
 DEFINE_INTERFACE_METHOD_1("SetSpeed", void, ICmpUnitMotion, SetSpeed, fixed)
-DEFINE_INTERFACE_METHOD_0("IsMoving", bool, ICmpUnitMotion, IsMoving)
-DEFINE_INTERFACE_METHOD_0("GetWalkSpeed", fixed, ICmpUnitMotion, GetWalkSpeed)
-DEFINE_INTERFACE_METHOD_0("GetRunSpeed", fixed, ICmpUnitMotion, GetRunSpeed)
+DEFINE_INTERFACE_METHOD_0("IsActuallyMoving", bool, ICmpUnitMotion, IsActuallyMoving)
+DEFINE_INTERFACE_METHOD_0("IsTryingToMove", bool, ICmpUnitMotion, IsTryingToMove)
+DEFINE_INTERFACE_METHOD_0("GetSpeed", fixed, ICmpUnitMotion, GetSpeed)
+DEFINE_INTERFACE_METHOD_0("GetTemplateSpeed", fixed, ICmpUnitMotion, GetTemplateSpeed)
 DEFINE_INTERFACE_METHOD_0("GetPassabilityClassName", std::string, ICmpUnitMotion, GetPassabilityClassName)
 DEFINE_INTERFACE_METHOD_0("GetUnitClearance", entity_pos_t, ICmpUnitMotion, GetUnitClearance)
 DEFINE_INTERFACE_METHOD_1("SetFacePointAfterMove", void, ICmpUnitMotion, SetFacePointAfterMove, bool)
@@ -66 +69 @@
         return m_Script.Call<bool>("MoveToTargetRange", target, minRange, maxRange);
     }
 
-    virtual void MoveToFormationOffset(entity_id_t target, entity_pos_t x, entity_pos_t z)
+    virtual void FaceTowardsPoint(entity_pos_t x, entity_pos_t z)
     {
-        m_Script.CallVoid("MoveToFormationOffset", target, x, z);
+        m_Script.CallVoid("FaceTowardsPoint", x, z);
     }
 
-    virtual void FaceTowardsPoint(entity_pos_t x, entity_pos_t z)
+    virtual void DiscardMove()
     {
-        m_Script.CallVoid("FaceTowardsPoint", x, z);
+        m_Script.CallVoid("DiscardMove");
     }
 
-    virtual void StopMoving()
+    virtual void CompleteMove()
     {
-        m_Script.CallVoid("StopMoving");
+        m_Script.CallVoid("CompleteMove");
     }
 
-    virtual fixed GetCurrentSpeed()
+    virtual void SetAbortIfStuck(u8 shouldAbort)
     {
-        return m_Script.Call<fixed>("GetCurrentSpeed");
+        m_Script.CallVoid("SetAbortIfStuck", shouldAbort);
+    }
+
+    virtual fixed GetActualSpeed()
+    {
+        return m_Script.Call<fixed>("GetActualSpeed");
     }
 
     virtual void SetSpeed(fixed speed)
@@ -91 +99 @@
         m_Script.CallVoid("SetSpeed", speed);
     }
 
-    virtual bool IsMoving()
+    virtual fixed GetTopSpeedRatio()
+    {
+        return m_Script.Call<fixed>("GetTopSpeedRatio");
+    }
+
+    virtual bool IsActuallyMoving()
+    {
+        return m_Script.Call<bool>("IsActuallyMoving");
+    }
+
+    virtual bool IsTryingToMove()
     {
-        return m_Script.Call<bool>("IsMoving");
+        return m_Script.Call<bool>("IsTryingToMove");
     }
 
-    virtual fixed GetWalkSpeed()
+    virtual fixed GetSpeed()
     {
-        return m_Script.Call<fixed>("GetWalkSpeed");
+        return m_Script.Call<fixed>("GetSpeed");
     }
 
-    virtual fixed GetRunSpeed()
+    virtual fixed GetTemplateSpeed()
     {
-        return m_Script.Call<fixed>("GetRunSpeed");
+        return m_Script.Call<fixed>("GetTemplateSpeed");
     }
 
     virtual void SetFacePointAfterMove(bool facePointAfterMove)
@@ -116 +134 @@
         return m_Script.Call<pass_class_t>("GetPassabilityClass");
     }
 
+    virtual fixed GetSpeedRatio()
+    {
+        return fixed::FromInt(1);
+    }
+
     virtual std::string GetPassabilityClassName()
     {
         return m_Script.Call<std::string>("GetPassabilityClassName");

source/simulation2/components/ICmpUnitMotion.h

@@ -71 +71 @@
     virtual bool MoveToTargetRange(entity_id_t target, entity_pos_t minRange, entity_pos_t maxRange) = 0;
 
     /**
-     * Join a formation, and move towards a given offset relative to the formation controller entity.
-     * Continues following the formation until given a different command.
+     * Turn to look towards the given point.
      */
-    virtual void MoveToFormationOffset(entity_id_t target, entity_pos_t x, entity_pos_t z) = 0;
+    virtual void FaceTowardsPoint(entity_pos_t x, entity_pos_t z) = 0;
 
     /**
-     * Turn to look towards the given point.
+     * Determine whether to abort or retry X times if pathing fails.
+     * Generally safer to let it abort and inform us.
      */
-    virtual void FaceTowardsPoint(entity_pos_t x, entity_pos_t z) = 0;
+    virtual void SetAbortIfStuck(u8 shouldAbort) = 0;
+
+    /**
+     * Stop moving immediately, don't send messages.
+     * This should be used if you are going to ask for a new path,
+     * in the same function, for example.
+     * In doubt, UnitAI should probably call this.
+     * Use with caution.
+     */
+    virtual void DiscardMove() = 0;
+
+    /**
+     * Stop moving immediately, send messages.
+     * In doubt, components that are not UnitIA should probably call this.
+     */
+    virtual void CompleteMove() = 0;
+
+    /**
+     * Get the movement speed from last turn to this turn
+     * This is effectively historical data
+     * And not a good indicator of whether we are actually moving,
+     * Prefer IsActuallyMoving
+     */
+    virtual fixed GetActualSpeed() = 0;
 
     /**
-     * Stop moving immediately.
+     * Get how much faster/slower we are at than normal.
      */
-    virtual void StopMoving() = 0;
+    virtual fixed GetSpeedRatio() = 0;
 
     /**
-     * Get the current movement speed.
+     * Get how much faster than our regular speed we can go.
      */
-    virtual fixed GetCurrentSpeed() = 0;
+    virtual fixed GetTopSpeedRatio() = 0;
 
     /**
      * Set the current movement speed.
+     * 'speed' in % of top speed (ie 3.0 will be 3 times top speed).
      */
     virtual void SetSpeed(fixed speed) = 0;
 
     /**
-     * Get whether the unit is moving.
+     * Get whether the unit is actually moving on the map this turn.
+     */
+    virtual bool IsActuallyMoving() = 0;
+
+    /**
+     * Get whether a unit is trying to go somewhere
+     * NB: this does not mean its position is actually changing right now.
      */
-    virtual bool IsMoving() = 0;
+    virtual bool IsTryingToMove() = 0;
 
     /**
-     * Get the default speed that this unit will have when walking, in metres per second.
+     * Get the unit theoretical speed in metres per second.
+     * GetActualSpeed will return historical speed
+     * This is affected by SetSpeed.
      */
-    virtual fixed GetWalkSpeed() = 0;
+    virtual fixed GetSpeed() = 0;
 
     /**
-     * Get the default speed that this unit will have when running, in metres per second.
+     * Get the unit template speed in metres per second.
+     * This is NOT affected by SetSpeed.
      */
-    virtual fixed GetRunSpeed() = 0;
+    virtual fixed GetTemplateSpeed() = 0;
 
     /**
      * Set whether the unit will turn to face the target point after finishing moving.

source/simulation2/components/ICmpVisual.cpp

@@ -24 +24 @@
 BEGIN_INTERFACE_WRAPPER(Visual)
 DEFINE_INTERFACE_METHOD_2("SetVariant", void, ICmpVisual, SetVariant, CStr, CStr)
 DEFINE_INTERFACE_METHOD_4("SelectAnimation", void, ICmpVisual, SelectAnimation, std::string, bool, fixed, std::wstring)
-DEFINE_INTERFACE_METHOD_1("SelectMovementAnimation", void, ICmpVisual, SelectMovementAnimation, fixed)
-DEFINE_INTERFACE_METHOD_1("ResetMoveAnimation", void, ICmpVisual, ResetMoveAnimation, std::string)
-DEFINE_INTERFACE_METHOD_2("ReplaceMoveAnimation", void, ICmpVisual, ReplaceMoveAnimation, std::string, std::string)
 DEFINE_INTERFACE_METHOD_1("SetAnimationSyncRepeat", void, ICmpVisual, SetAnimationSyncRepeat, fixed)
 DEFINE_INTERFACE_METHOD_1("SetAnimationSyncOffset", void, ICmpVisual, SetAnimationSyncOffset, fixed)
 DEFINE_INTERFACE_METHOD_4("SetShadingColor", void, ICmpVisual, SetShadingColor, fixed, fixed, fixed, fixed)

source/simulation2/components/ICmpVisual.h

@@ -99 +99 @@
     virtual void SelectAnimation(const std::string& name, bool once, fixed speed, const std::wstring& soundgroup) = 0;
 
     /**
-     * Replaces a specified animation with another. Only affects the special speed-based
-     * animation determination behaviour.
-     * @param name Animation to match.
-     * @param replace Animation that should replace the matched animation.
+     * if moving is true, start playing the walk/run animations, scaled to the unit's movement speed.
      */
-    virtual void ReplaceMoveAnimation(const std::string& name, const std::string& replace) = 0;
-
-    /**
-     * Ensures that the given animation will be used when it normally would be,
-     * removing reference to any animation that might replace it.
-     * @param name Animation name to remove from the replacement map.
-     */
-    virtual void ResetMoveAnimation(const std::string& name) = 0;
-
-    /**
-     * Start playing the walk/run animations, scaled to the unit's movement speed.
-     * @param runThreshold movement speed at which to switch to the run animation
-     */
-    virtual void SelectMovementAnimation(fixed runThreshold) = 0;
+    virtual void SetMoving(bool moving) = 0;
 
     /**
      * Adjust the speed of the current animation, so it can match simulation events.

source/simulation2/scripting/MessageTypeConversions.cpp

@@ -267 +267 @@
 
 ////////////////////////////////
 
-JS::Value CMessageMotionChanged::ToJSVal(ScriptInterface& scriptInterface) const
+JS::Value CMessageBeginMove::ToJSVal(ScriptInterface& scriptInterface) const
 {
     TOJSVAL_SETUP();
-    SET_MSG_PROPERTY(starting);
-    SET_MSG_PROPERTY(error);
     return JS::ObjectValue(*obj);
 }
 
-CMessage* CMessageMotionChanged::FromJSVal(ScriptInterface& scriptInterface, JS::HandleValue val)
+CMessage* CMessageBeginMove::FromJSVal(ScriptInterface& scriptInterface, JS::HandleValue val)
 {
     FROMJSVAL_SETUP();
-    GET_MSG_PROPERTY(bool, starting);
-    GET_MSG_PROPERTY(bool, error);
-    return new CMessageMotionChanged(starting, error);
+    return new CMessageBeginMove();
+}
+
+////////////////////////////////
+
+JS::Value CMessagePausedMove::ToJSVal(ScriptInterface& scriptInterface) const
+{
+    TOJSVAL_SETUP();
+    return JS::ObjectValue(*obj);
+}
+
+CMessage* CMessagePausedMove::FromJSVal(ScriptInterface& scriptInterface, JS::HandleValue val)
+{
+    FROMJSVAL_SETUP();
+    return new CMessagePausedMove();
+}
+
+////////////////////////////////
+
+JS::Value CMessageFinishedMove::ToJSVal(ScriptInterface& scriptInterface) const
+{
+    TOJSVAL_SETUP();
+    SET_MSG_PROPERTY(failed);
+    return JS::ObjectValue(*obj);
+}
+
+CMessage* CMessageFinishedMove::FromJSVal(ScriptInterface& scriptInterface, JS::HandleValue val)
+{
+    FROMJSVAL_SETUP();
+    GET_MSG_PROPERTY(bool, failed);
+    return new CMessageFinishedMove(failed);
 }
 
 ////////////////////////////////

source/tools/atlas/GameInterface/ActorViewer.cpp

@@ -375 +375 @@
         {
             CmpPtr<ICmpUnitMotion> cmpUnitMotion(m.Simulation2, m.Entity);
             if (cmpUnitMotion)
-                speed = cmpUnitMotion->GetWalkSpeed().ToFloat();
+                speed = cmpUnitMotion->GetTemplateSpeed().ToFloat();
             else
                 speed = 7.f; // typical unit speed
 
@@ -385 +385 @@
         {
             CmpPtr<ICmpUnitMotion> cmpUnitMotion(m.Simulation2, m.Entity);
             if (cmpUnitMotion)
-                speed = cmpUnitMotion->GetRunSpeed().ToFloat();
+                speed = cmpUnitMotion->GetTemplateSpeed().ToFloat();
             else
                 speed = 12.f; // typical unit speed