Question

I’m calculating increments from point A (top right) to point B (bottom left) with the following code. But as we get closer to point B, my increments get further and further off the expected path. The green line in the picture is the expected path of the white dot.

    public function get target():Point { return _target; }
    public function set target(p:Point):void
    {
        _target = p;
        var dist:Number = distanceTwoPoints(x, _target.x, y, _target.y); //find the linear distance
        //double the steps to get more accurate calculations. 2 steps are calculated each frame
        var _stepT:Number = 2 * (dist * _speed); //_speed is in frames/pixel (something like 0.2)

        if (_stepT < 1) //Make sure there's at least 1 step
            _stepT = 1;
        _stepTotal = int(_stepT); //ultimately, we cannot have half a step
        xInc = (_target.x - x) / _stepT; //calculate the xIncrement based on the number of steps (distance / time)
        yInc = (_target.y - y) / _stepT;
    }

    private function distanceTwoPoints(x1:Number, x2:Number, y1:Number, y2:Number):Number 
    {
        var dx:Number = x1-x2;
        var dy:Number = y1-y2;
        return Math.sqrt(dx * dx + dy * dy);
    }

Basically, I’m out of ideas. The only thing that seems to get the white dot to follow the green line exactly is to adjust the target’s position like so:

distanceTwoPoints(x, _target.x + 2, y, _target.y + 1);
//...
xInc = (_target.x + 2 - x) / _stepT;
yInc = (_target.y + 1 - y) / _stepT;

However, this throws off other parts of the simulation where there is no angle between points, like coming into point A (top right). This makes me think the distance between the two points needs to be calculated as shorter than it actually is. Any ideas?

Answer 1

Flash has a great function that is really handy for this. Point.interpolate(pointA, pointB, number) It returns a point between points A and B. The third input (Number) is how close to pointA or pointB the resulting point should be, from 0 to 1. You’ll have to calculate its value.

What interpolate does is basically a weighted average of the two input points, the number being the weight towards one point. If the number is 0.5, you’ll get a point halfway between the two input points. 1 returns PointA, 0 returns PointB.

flash.geom.Point.interpolate() for details.

For other languages, or math in general, you can do it this way, no Trig required: point1, the origin, and point2 the end point. point3 is a point between point1 and point2. loc is a ratio from point1 to point2, how far down the line to go. loc = .25 would be a quarter of the way from point1 towards point2. point3.x = point1.x * (1 - loc) + point2.x * loc and point3.y = point1.y * (1 - loc) + point2.y * loc. This will even work for values outside of 0-1, such as a point on the line connecting point1 and point2 but not between them.