Ticket #1537: chasing.3.diff

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

@@ -16 +16 @@
 Timer.prototype.GetTime = function()
 {
     return this.time;
-}
+};
 
 /**
+ * Returns the turn length of the latest turn in millisecons
+ */
+Timer.prototype.GetTurnLength = function()
+{
+    return this.turnLength;
+};
+
+/**
  * Create a new timer, which will call the 'funcname' method with arguments (data, lateness)
  * on the 'iid' component of the 'ent' entity, after at least 'time' milliseconds.
  * 'lateness' is how late the timer is executed after the specified time (in milliseconds).
@@ -60 +68 @@
 
 Timer.prototype.OnUpdate = function(msg)
 {
-    var dt = Math.round(msg.turnLength * 1000);
-    this.time += dt;
+    this.turnLength = Math.round(msg.turnLength * 1000);
+    this.time += this.turnLength;
 
     // Collect the timers that need to run
     // (We do this in two stages to avoid deleting from the timer list while

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

@@ -171 +171 @@
         // ignore
     },
 
+    "Update": function(msg) {
+        // ignore
+    },
+
     // Formation handlers:
 
     "FormationLeave": function(msg) {
@@ -378 +382 @@
         // We use the distance between the entities to account for ranged attacks
         var distance = DistanceBetweenEntities(this.entity, this.order.data.target) + (+this.template.FleeDistance);
         var cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
-        if (cmpUnitMotion.MoveToTargetRange(this.order.data.target, distance, -1))
+        if (cmpUnitMotion.MoveToTargetRange(this.order.data.target, distance, -1, 0))
         {
             // We've started fleeing from the given target
             if (this.IsAnimal())
@@ -413 +417 @@
         this.order.data.attackType = type;
 
         // If we are already at the target, try attacking it from here
-        if (this.CheckTargetAttackRange(this.order.data.target, IID_Attack, this.order.data.attackType))
+        if (this.CheckTargetAttackRange(this.order.data.target, this.order.data.attackType))
         {
             this.StopMoving();
             // For packable units within attack range:
@@ -485 +489 @@
         }
 
         // Try to move within attack range
-        if (this.MoveToTargetAttackRange(this.order.data.target, IID_Attack, this.order.data.attackType))
+        if (this.MoveToTargetAttackRange(this.order.data.target, this.order.data.attackType))
         {
             // We've started walking to the given point
             if (this.IsAnimal())
@@ -1590 +1594 @@
 
                 "MoveCompleted": function() {
 
-                    if (this.CheckTargetAttackRange(this.order.data.target, IID_Attack , this.order.data.attackType)) 
+                    if (this.CheckTargetAttackRange(this.order.data.target, this.order.data.attackType)) 
                     {
                         // If the unit needs to unpack, do so
                         if (this.CanUnpack())
@@ -1600 +1604 @@
                     } 
                     else 
                     {
-                        if (this.MoveToTargetAttackRange(this.order.data.target, IID_Attack, this.order.data.attackType))
+                        if (this.MoveToTargetAttackRange(this.order.data.target, this.order.data.attackType))
                         {
                             this.SetNextState("APPROACHING");
                         }
@@ -1625 +1629 @@
             "UNPACKING": {
                 "enter": function() {
                     // If we're not in range yet (maybe we stopped moving), move to target again
-                    if (!this.CheckTargetAttackRange(this.order.data.target, IID_Attack, this.order.data.attackType))
+                    if (!this.CheckTargetAttackRange(this.order.data.target, this.order.data.attackType))
                     {
-                        if (this.MoveToTargetAttackRange(this.order.data.target, IID_Attack, this.order.data.attackType))
+                        if (this.MoveToTargetAttackRange(this.order.data.target, this.order.data.attackType))
                             this.SetNextState("APPROACHING");
                         else
                         {
@@ -1690 +1694 @@
                 "Timer": function(msg) {
                     var target = this.order.data.target;
                     // Check the target is still alive and attackable
-                    if (this.TargetIsAlive(target) && this.CanAttack(target, this.order.data.forceResponse || null))
+                    if 
+                    (
+                        !this.TargetIsAlive(target) || 
+                        !this.CanAttack(target, this.order.data.forceResponse || null) ||
+                        !this.CheckTargetAttackRange(target, this.order.data.attackType)
+                    )
+                        return;
+
+                    // If we are hunting, first update the target position of the gather order so we know where will be the killed animal
+                    if (this.order.data.hunting && this.orderQueue[1] && this.orderQueue[1].data.lastPos)
                     {
-                        // Check we can still reach the target
-                        if (this.CheckTargetAttackRange(target, IID_Attack, this.order.data.attackType))
+                        var cmpPosition = Engine.QueryInterface(this.order.data.target, IID_Position);
+                        if (cmpPosition && cmpPosition.IsInWorld())
                         {
-                            // If we are hunting, first update the target position of the gather order so we know where will be the killed animal
-                            if (this.order.data.hunting && this.orderQueue[1] && this.orderQueue[1].data.lastPos)
-                            {
-                                var cmpPosition = Engine.QueryInterface(this.order.data.target, IID_Position);
-                                if (cmpPosition && cmpPosition.IsInWorld())
-                                {
-                                    // Store the initial position, so that we can find the rest of the herd later
-                                    if (!this.orderQueue[1].data.initPos)
-                                        this.orderQueue[1].data.initPos = this.orderQueue[1].data.lastPos;
-                                    this.orderQueue[1].data.lastPos = cmpPosition.GetPosition();
-                                    // We still know where the animal is, so we shouldn't give up before going there
-                                    this.orderQueue[1].data.secondTry = undefined;
-                                }
-                            }
+                            // Store the initial position, so that we can find the rest of the herd later
+                            if (!this.orderQueue[1].data.initPos)
+                                this.orderQueue[1].data.initPos = this.orderQueue[1].data.lastPos;
+                            this.orderQueue[1].data.lastPos = cmpPosition.GetPosition();
+                            // We still know where the animal is, so we shouldn't give up before going there
+                            this.orderQueue[1].data.secondTry = undefined;
+                        }
+                    }
 
-                            var cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
-                            this.lastAttacked = cmpTimer.GetTime() - msg.lateness;
+                    var cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
+                    this.lastAttacked = cmpTimer.GetTime() - msg.lateness;
 
-                            this.FaceTowardsTarget(target);
-                            var cmpAttack = Engine.QueryInterface(this.entity, IID_Attack);
-                            cmpAttack.PerformAttack(this.order.data.attackType, target);
+                    this.FaceTowardsTarget(target);
+                    var cmpAttack = Engine.QueryInterface(this.entity, IID_Attack);
+                    cmpAttack.PerformAttack(this.order.data.attackType, target);
 
-                            if (this.resyncAnimation)
-                            {
-                                this.SetAnimationSync(this.attackTimers.repeat, this.attackTimers.repeat);
-                                this.resyncAnimation = false;
-                            }
-                            return;
-                        }
+                    if (this.resyncAnimation)
+                    {
+                        this.SetAnimationSync(this.attackTimers.repeat, this.attackTimers.repeat);
+                        this.resyncAnimation = false;
+                    }
+                },
 
-                        // Can't reach it - try to chase after it
-                        if (this.ShouldChaseTargetedEntity(target, this.order.data.force))
-                        {
-                            if (this.MoveToTargetRange(target, IID_Attack, this.order.data.attackType))
-                            {
-                                this.SetNextState("COMBAT.CHASING");
-                                return;
-                            }
-                        }
+                // respond to target position changes and target deaths immediately
+                "Update": function(msg) {
+                    var target = this.order.data.target;
+                    var attackType = this.order.data.attackType;
+                    if 
+                    (
+                        this.TargetIsAlive(target) &&
+                        this.CanAttack(target, this.order.data.forceResponse || null)
+                    )
+                    {
+                        if
+                        (
+                            !this.CheckTargetAttackRange(target, attackType) &&
+                            this.ShouldChaseTargetedEntity(target, this.order.data.force) &&
+                            this.MoveToTargetAttackRange(target, attackType)
+                        )
+                            this.SetNextState("COMBAT.CHASING");
+                        return;
                     }
 
-                    this.oldAttackType = this.order.data.attackType;
+                    this.oldAttackType = attackType;
                     // Can't reach it, no longer owned by enemy, or it doesn't exist any more - give up
                     // Except if in WalkAndFight mode where we look for more ennemies around before moving again
                     if (this.FinishOrder())
@@ -1760 +1775 @@
                         this.WalkToHeldPosition();
                 },
 
-                // TODO: respond to target deaths immediately, rather than waiting
-                // until the next Timer event
-
                 "Attacked": function(msg) {
                     if (this.order.data.target != msg.data.attacker)
                     {
@@ -3587 +3599 @@
     UnitFsm.ProcessMessage(this, {"type": "PackFinished", "packed": msg.packed});
 };
 
+UnitAI.prototype.OnUpdate = function(msg)
+{
+    UnitFsm.ProcessMessage(this, {"type": "Update", "data": msg});
+}
+
 //// Helper functions to be called by the FSM ////
 
 UnitAI.prototype.GetWalkSpeed = function()
@@ -3856 +3873 @@
         return false;
 
     var cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
-    return cmpUnitMotion.MoveToTargetRange(target, 0, 0);
+    return cmpUnitMotion.MoveToTargetRange(target, 0, 0, 0);
 };
 
-UnitAI.prototype.MoveToTargetRange = function(target, iid, type)
+UnitAI.prototype.MoveToTargetRange = function(target, iid, type, time)
 {
     if (!this.CheckTargetVisible(target))
         return false;
@@ -3868 +3885 @@
     if (!cmpRanged)
         return false;
     var range = cmpRanged.GetRange(type);
+    if (!time) 
+        time = 0;
 
     var cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
-    return cmpUnitMotion.MoveToTargetRange(target, range.min, range.max);
+    return cmpUnitMotion.MoveToTargetRange(target, range.min, range.max, time);
 };
 
 /**
@@ -3878 +3897 @@
  * for melee attacks, this goes straight to the default range checks
  * for ranged attacks, the parabolic range is used
  */
-UnitAI.prototype.MoveToTargetAttackRange = function(target, iid, type)
+UnitAI.prototype.MoveToTargetAttackRange = function(target, type)
 {
+    var cmpAttack = Engine.QueryInterface(this.entity, IID_Attack);
+    var cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
+    var timers = cmpAttack.GetTimers(type);
+    // add one turnlength, as even without prepare time, there's one turn between stopping
+    // to move and starting to attack
+    var time = timers.prepare + cmpTimer.GetTurnLength() / 1000; 
 
     if(type!= "Ranged") 
-        return this.MoveToTargetRange(target, iid, type);
+        return this.MoveToTargetRange(target, IID_Attack, type, time);
     
     if (!this.CheckTargetVisible(target)) 
         return false;
     
-    var cmpRanged = Engine.QueryInterface(this.entity, iid);
-    var range = cmpRanged.GetRange(type);
+    var range = cmpAttack.GetRange(type);
 
     var thisCmpPosition = Engine.QueryInterface(this.entity, IID_Position);
     var s = thisCmpPosition.GetPosition();
@@ -3913 +3937 @@
     var guessedMaxRange = (range.max + parabolicMaxRange)/2;
 
     var cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
-    if (cmpUnitMotion.MoveToTargetRange(target, range.min, guessedMaxRange))
+    if (cmpUnitMotion.MoveToTargetRange(target, range.min, guessedMaxRange, time))
         return true;
 
     // if that failed, try closer
-    return cmpUnitMotion.MoveToTargetRange(target, range.min, Math.min(range.max, parabolicMaxRange));
+    return cmpUnitMotion.MoveToTargetRange(target, range.min, Math.min(range.max, parabolicMaxRange), time);
 };
 
-UnitAI.prototype.MoveToTargetRangeExplicit = function(target, min, max)
+UnitAI.prototype.MoveToTargetRangeExplicit = function(target, min, max, time)
 {
     if (!this.CheckTargetVisible(target))
         return false;
 
+    if (!time)
+        time = 0;
+
     var cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
-    return cmpUnitMotion.MoveToTargetRange(target, min, max);
+    return cmpUnitMotion.MoveToTargetRange(target, min, max, time);
 };
 
 UnitAI.prototype.MoveToGarrisonRange = function(target)
@@ -3940 +3967 @@
     var range = cmpGarrisonHolder.GetLoadingRange();
 
     var cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
-    return cmpUnitMotion.MoveToTargetRange(target, range.min, range.max);
+    return cmpUnitMotion.MoveToTargetRange(target, range.min, range.max, 0);
 };
 
 UnitAI.prototype.CheckPointRangeExplicit = function(x, z, min, max)
@@ -3966 +3993 @@
  * For ranged attacks, the parabolic formula is used to accout for bigger ranges
  * when the target is lower, and smaller ranges when the target is higher
  */ 
-UnitAI.prototype.CheckTargetAttackRange = function(target, iid, type)
+UnitAI.prototype.CheckTargetAttackRange = function(target, type)
 {
 
     if (type != "Ranged") 
-        return this.CheckTargetRange(target,iid,type);
+        return this.CheckTargetRange(target, IID_Attack, type);
     
     var targetCmpPosition = Engine.QueryInterface(target, IID_Position);
     if (!targetCmpPosition || !targetCmpPosition.IsInWorld()) 
         return false; 
 
-    var cmpRanged = Engine.QueryInterface(this.entity, iid);
+    var cmpRanged = Engine.QueryInterface(this.entity, IID_Attack);
     var range = cmpRanged.GetRange(type);
 
     var thisCmpPosition = Engine.QueryInterface(this.entity, IID_Position);
@@ -4220 +4247 @@
         if (cmpUnitAI && cmpAttack)
         {
             for each (var type in cmpAttack.GetAttackTypes())
-                if (cmpUnitAI.CheckTargetAttackRange(this.isGuardOf, IID_Attack, type))
+                if (cmpUnitAI.CheckTargetAttackRange(this.isGuardOf, type))
                     return false;
         }
     }
@@ -4267 +4294 @@
         if (cmpUnitAI && cmpAttack)
         {
             for each (var type in cmpAttack.GetAttackTypes())
-                if (cmpUnitAI.CheckTargetAttackRange(this.isGuardOf, IID_Attack, type))
+                if (cmpUnitAI.CheckTargetAttackRange(this.isGuardOf, type))
                     return true;
         }
     }

binaries/data/mods/public/simulation/templates/template_unit_cavalry_melee_swordsman.xml

@@ -5 +5 @@
       <Hack>10.0</Hack>
       <Pierce>0.0</Pierce>
       <Crush>0.0</Crush>
-      <MaxRange>6.0</MaxRange>
+      <MaxRange>4.0</MaxRange>
       <Bonuses>
         <BonusPrimary>
           <Classes>Support</Classes>

source/simulation2/components/CCmpObstruction.cpp

@@ -442 +442 @@
         return m_Tag;
     }
 
+    virtual bool GetPreviousObstructionSquare(ICmpObstructionManager::ObstructionSquare& out)
+    {
+        return GetObstructionSquare(out, true);
+    }
+
     virtual bool GetObstructionSquare(ICmpObstructionManager::ObstructionSquare& out)
     {
+        return GetObstructionSquare(out, false);
+    }
+
+    virtual bool GetObstructionSquare(ICmpObstructionManager::ObstructionSquare& out, bool previousPosition)
+    {
         CmpPtr<ICmpPosition> cmpPosition(GetEntityHandle());
         if (!cmpPosition)
             return false; // error
@@ -455 +465 @@
         if (!cmpPosition->IsInWorld())
             return false; // no obstruction square
 
-        CFixedVector2D pos = cmpPosition->GetPosition2D();
+        CFixedVector2D pos;
+        if (previousPosition)
+            pos = cmpPosition->GetPreviousPosition2D();
+        else
+            pos = cmpPosition->GetPosition2D();
         if (m_Type == STATIC)
             out = cmpObstructionManager->GetStaticShapeObstruction(pos.X, pos.Y, cmpPosition->GetRotation().Y, m_Size0, m_Size1);
         else if (m_Type == UNIT)

source/simulation2/components/CCmpUnitMotion.cpp

@@ -132 +132 @@
     bool m_FormationController;
     fixed m_WalkSpeed, m_OriginalWalkSpeed; // in metres per second
     fixed m_RunSpeed, m_OriginalRunSpeed;
+    fixed m_TimeToStayInRange;
     ICmpPathfinder::pass_class_t m_PassClass;
     ICmpPathfinder::cost_class_t m_CostClass;
 
@@ -297 +298 @@
         m_WalkSpeed = m_OriginalWalkSpeed = paramNode.GetChild("WalkSpeed").ToFixed();
         m_Speed = m_WalkSpeed;
         m_CurSpeed = fixed::Zero();
+        m_TimeToStayInRange = fixed::Zero();
 
         if (paramNode.GetChild("Run").IsOk())
             m_RunSpeed = m_OriginalRunSpeed = paramNode.GetChild("Run").GetChild("Speed").ToFixed();
@@ -350 +352 @@
 
         serialize.NumberFixed_Unbounded("speed", m_Speed);
 
+        serialize.NumberFixed_Unbounded("timeToStayInRange", m_TimeToStayInRange);
+
         serialize.Bool("moving", m_Moving);
         serialize.Bool("facePointAfterMove", m_FacePointAfterMove);
 
@@ -388 +392 @@
         {
             if (!m_FormationController)
             {
-                fixed dt = static_cast<const CMessageUpdate_MotionUnit&> (msg).turnLength;
+                fixed dt = static_cast<const CMessageUpdate_MotionFormation&> (msg).turnLength;
                 Move(dt);
             }
             break;
@@ -470 +474 @@
 
     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 MoveToTargetRange(entity_id_t target, entity_pos_t minRange, entity_pos_t maxRange, entity_pos_t timeToStayInRange);
     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);
 
@@ -995 +999 @@
                         }
                         else
                         {
+                            // check if target was reached in case of a moving target
+                            CmpPtr<ICmpUnitMotion> cmpUnitMotion(GetSimContext(), m_TargetEntity);
+                            if 
+                            (
+                                cmpUnitMotion && 
+                                cmpUnitMotion->IsMoving() &&
+                                !IsInTargetRange(m_TargetEntity, m_TargetMinRange, m_TargetMaxRange) &&
+                                MoveToTargetRange(m_TargetEntity, m_TargetMinRange, m_TargetMaxRange, m_TimeToStayInRange)
+                            )
+                                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
@@ -1305 +1320 @@
 
 bool CCmpUnitMotion::MoveToPointRange(entity_pos_t x, entity_pos_t z, entity_pos_t minRange, entity_pos_t maxRange, entity_id_t target)
 {
+    // TODO also take moving targets into account, like in MoveToTargetRange
     PROFILE("MoveToPointRange");
 
     CmpPtr<ICmpPosition> cmpPosition(GetEntityHandle());
@@ -1383 +1399 @@
     m_TargetOffset = CFixedVector2D();
     m_TargetMinRange = minRange;
     m_TargetMaxRange = maxRange;
+    m_TimeToStayInRange = fixed::Zero();
     m_FinalGoal = goal;
 
     BeginPathing(pos, goal);
@@ -1454 +1471 @@
     return (errCircle < errSquare);
 }
 
-bool CCmpUnitMotion::MoveToTargetRange(entity_id_t target, entity_pos_t minRange, entity_pos_t maxRange)
+bool CCmpUnitMotion::MoveToTargetRange(entity_id_t target, entity_pos_t minRange, entity_pos_t maxRange, entity_pos_t timeToStayInRange)
 {
     PROFILE("MoveToTargetRange");
 
@@ -1501 +1518 @@
 
     if (hasObstruction)
     {
+        CmpPtr<ICmpPosition> cmpTargetPosition(GetSimContext(), target);
+        if (!cmpTargetPosition || !cmpTargetPosition->IsInWorld())
+            return false;
+        
+        // if the target is moving, take an overshoot into account
+        entity_pos_t overShoot = fixed::Zero();
+        CmpPtr<ICmpUnitMotion> cmpUnitMotion(GetSimContext(), target);
+        if (cmpUnitMotion)
+            overShoot = cmpUnitMotion->GetCurrentSpeed().Multiply(timeToStayInRange);
+
+        // get the rotation difference, and bring it to the (-pi,pi] interval
+        fixed rotationDifference = cmpPosition->GetRotation().Y - cmpTargetPosition->GetRotation().Y;
+        fixed Pi = fixed::Pi();
+        while (rotationDifference > Pi)
+            rotationDifference -= Pi * 2;
+        while (rotationDifference <= -Pi)
+            rotationDifference += Pi * 2;
+
+        // take the rotation into account to decide which range to change
+        entity_pos_t newMaxRange = maxRange;
+        entity_pos_t newMinRange = minRange;
+        if (rotationDifference < Pi / 2 && rotationDifference > -Pi / 2)
+            newMaxRange -= overShoot;
+        else
+            newMinRange += overShoot;
+        // make sure the ranges are possible, and have the same behaviour 
+        if (newMaxRange <= minRange && maxRange >= minRange)
+            newMaxRange = minRange;
+        if (maxRange > fixed::Zero() && newMinRange > newMaxRange)
+            newMinRange = newMaxRange;
+
         CFixedVector2D halfSize(obstruction.hw, obstruction.hh);
         ICmpPathfinder::Goal goal;
         goal.x = obstruction.x;
@@ -1514 +1562 @@
 
             // TODO: maybe we should do the ShouldTreatTargetAsCircle thing here?
 
-            entity_pos_t goalDistance = minRange + g_GoalDelta;
+            entity_pos_t goalDistance = newMinRange + g_GoalDelta;
 
             goal.type = ICmpPathfinder::Goal::SQUARE;
             goal.u = obstruction.u;
@@ -1554 +1602 @@
                     return false;
                 }
 
-                entity_pos_t goalDistance = maxRange - g_GoalDelta;
+                entity_pos_t goalDistance = newMaxRange - g_GoalDelta;
 
                 goal.type = ICmpPathfinder::Goal::CIRCLE;
                 goal.hw = circleRadius + goalDistance;
@@ -1564 +1612 @@
                 // The target is large relative to our range, so treat it as a square and
                 // get close enough that the diagonals come within range
 
-                entity_pos_t goalDistance = (maxRange - g_GoalDelta)*2 / 3; // multiply by slightly less than 1/sqrt(2)
+                entity_pos_t goalDistance = (newMaxRange - g_GoalDelta)*2 / 3; // multiply by slightly less than 1/sqrt(2)
 
                 goal.type = ICmpPathfinder::Goal::SQUARE;
                 goal.u = obstruction.u;
@@ -1580 +1628 @@
         m_TargetOffset = CFixedVector2D();
         m_TargetMinRange = minRange;
         m_TargetMaxRange = maxRange;
+        m_TimeToStayInRange = timeToStayInRange;
         m_FinalGoal = goal;
 
         BeginPathing(pos, goal);
@@ -1626 +1675 @@
         CFixedVector2D halfSize(obstruction.hw, obstruction.hh);
         entity_pos_t distance = Geometry::DistanceToSquare(pos - CFixedVector2D(obstruction.x, obstruction.z), obstruction.u, obstruction.v, halfSize);
 
+        // compare with previous obstruction
+        ICmpObstructionManager::ObstructionSquare previousObstruction;
+        cmpObstruction->GetObstructionSquare(previousObstruction);
+        entity_pos_t previousDistance = Geometry::DistanceToSquare(pos - CFixedVector2D(previousObstruction.x, previousObstruction.z), obstruction.u, obstruction.v, halfSize);
+        
         // See if we're too close to the target square
-        if (distance < minRange)
+        if (distance < minRange && previousDistance < minRange)
             return false;
 
         // See if we're close enough to the target square
-        if (maxRange < entity_pos_t::Zero() || distance <= maxRange)
+        if (maxRange < entity_pos_t::Zero() || distance <= maxRange || previousDistance <= maxRange)
             return true;
 
         entity_pos_t circleRadius = halfSize.Length();
@@ -1645 +1699 @@
 
             if (circleDistance <= maxRange)
                 return true;
+            // also check circle around previous position
+            circleDistance = (pos - CFixedVector2D(previousObstruction.x, previousObstruction.z)).Length() - circleRadius;
+
+            if (circleDistance <= maxRange)
+                return true;
         }
 
         return false;
@@ -1655 +1714 @@
         if (!cmpTargetPosition || !cmpTargetPosition->IsInWorld())
             return false;
 
-        CFixedVector2D targetPos = cmpTargetPosition->GetPosition2D();
+        CFixedVector2D targetPos = cmpTargetPosition->GetPreviousPosition2D();
 
         entity_pos_t distance = (pos - targetPos).Length();
 
-        if (minRange <= distance && (maxRange < entity_pos_t::Zero() || distance <= maxRange))
-            return true;
-
-        return false;
+        return minRange <= distance && 
+            (maxRange < entity_pos_t::Zero() || distance <= maxRange);
     }
 }
 

source/simulation2/components/ICmpObstruction.h

@@ -47 +47 @@
      */
     virtual bool GetObstructionSquare(ICmpObstructionManager::ObstructionSquare& out) = 0;
 
+    /**
+     * Same as the method above, but returns an obstruction shape for the previous turn
+     */
+    virtual bool GetPreviousObstructionSquare(ICmpObstructionManager::ObstructionSquare& out) = 0;
+
     virtual entity_pos_t GetUnitRadius() = 0;
 
     virtual bool IsControlPersistent() = 0;

source/simulation2/components/ICmpUnitMotion.cpp

@@ -26 +26 @@
 DEFINE_INTERFACE_METHOD_4("MoveToPointRange", bool, ICmpUnitMotion, MoveToPointRange, entity_pos_t, entity_pos_t, entity_pos_t, entity_pos_t)
 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_4("MoveToTargetRange", bool, ICmpUnitMotion, MoveToTargetRange, entity_id_t, entity_pos_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)
@@ -60 +60 @@
         return m_Script.Call<bool>("IsInTargetRange", target, minRange, maxRange);
     }
 
-    virtual bool MoveToTargetRange(entity_id_t target, entity_pos_t minRange, entity_pos_t maxRange)
+    virtual bool MoveToTargetRange(entity_id_t target, entity_pos_t minRange, entity_pos_t maxRange, entity_pos_t timeToStayInRange)
     {
-        return m_Script.Call<bool>("MoveToTargetRange", target, minRange, maxRange);
+        return m_Script.Call<bool>("MoveToTargetRange", target, minRange, maxRange, timeToStayInRange);
     }
 
     virtual void MoveToFormationOffset(entity_id_t target, entity_pos_t x, entity_pos_t z)

source/simulation2/components/ICmpUnitMotion.h

@@ -66 +66 @@
      * and sends another MotionChanged after finishing moving.
      * If maxRange is negative, then the maximum range is treated as infinity.
      */
-    virtual bool MoveToTargetRange(entity_id_t target, entity_pos_t minRange, entity_pos_t maxRange) = 0;
+    virtual bool MoveToTargetRange(entity_id_t target, entity_pos_t minRange, entity_pos_t maxRange, entity_pos_t timeToStayInRange) = 0;
 
     /**
      * Join a formation, and move towards a given offset relative to the formation controller entity.