Converting complicated trigonometry from AS2 to AS3

Question

I'm trying to make a game, following this tutorial.

The issue comes from the fact that I am using ActionScript 3.0 whereas the tutorial was written using ActionScript 2.0.

Regarding the sight of the enemy, I have turned this code:

onClipEvent (enterFrame) {
dist_x = _root.hero._x-_x;
dist_y = _root.hero._y-_y;
dist = Math.sqrt(dist_x*dist_x+dist_y*dist_y);
angle = Math.atan(dist_y/dist_x)/(Math.PI/180);
if (dist_x<0) {
    angle += 180;
}
if (dist_x>=0 && dist_y<0) {
    angle += 360;
}
wall_collision = 0;
for (x=1; x<=dist; x++) {
    point_x = _x+x*Math.cos(angle*Math.PI/180);
    point_y = _y+x*Math.sin(angle*Math.PI/180);
    if (_root.wall.hitTest(point_x, point_y, true)) {
        wall_collision = 100;
        break;
    }
}
_root.line._x = _x;
_root.line._y = _y;
_root.line._rotation = angle;
_root.line._alpha = 100-wall_collision;
}

Into that:

// calculate rotation based on target
_dx = this.x - _root.hero.x;
_dy = this.y - _root.hero.y;
// which way to rotate
_rotateTo = getDegrees(getRadians(_dx, _dy));   

// keep rotation positive, between 0 and 360 degrees
if (_rotateTo > barrel.rotation + 90) _rotateTo -= 360;
if (_rotateTo < barrel.rotation - 90) _rotateTo += 360;

// ease rotation
_trueRotation = (_rotateTo - barrel.rotation) / _rotateSpeedMax;

// update rotation
barrel.rotation += _trueRotation;   

wall_collision = 0;

OuterLoop: for (var xi=1; xi<=_dx; xi++)
{
    var point_x:Number = this.x + xi*Math.cos(_rotateTo);
    var point_y:Number = this.y + xi*Math.sin(_rotateTo);

    if(_root.wall.hitTestPoint(point_x, point_y, true))
    {
        trace("HIT");
        wall_collision = 100;
        break OuterLoop;
    }
}

_root.sight.x = this.x;
_root.sight.y = this.y;
_root.sight.rotation += _trueRotation;
_root.sight.alpha = 100 - wall_collision;

But the it does not work.

The rotation do work fine, but the whole "alpha = 0 if player is behind a wall" does not work.

Please help me resolving the issue.

Answer 1

Try the following:

// calculate rotation based on target
_dx = _root.hero.x-this.x;
_dy = _root.hero.y-this.y;

// The full distance is missing from your AS3 code
_dist = Math.sqrt(_dx*_dx+_dy*_dy);

// Return the old good approach for finding angle
angle = Math.atan(_dy/_dx)/(Math.PI/180);
if (_dx<0) {
    _angle += 180;
}
if (_dx>=0 && _dy<0) {
    _angle += 360;
}

wall_collision = 0;

OuterLoop: for (var xi=1; xi<=_dist; xi++)
{
    var point_x:Number = this.x + xi*Math.cos(_angle*Math.PI/180);
    var point_y:Number = this.y + xi*Math.sin(_angle*Math.PI/180);

    if(_root.wall.hitTestPoint(point_x, point_y, true))
    {
        trace("HIT");
        wall_collision = 100;
        break OuterLoop;
    }
}

_root.sight.x = this.x;
_root.sight.y = this.y;
_root.sight.rotation = _angle;

// Alpha changed from [0, 100] scale to [0, 1] scale.
_root.sight.alpha = (100 - wall_collision) * 0.01;

Information on alpha in ActionScript 3.0.

Answer 2

As per AS3 reference, alpha is from 0 to 1, not 0 to 100. That would suggest `_root.sight.alpha = (100 - wall_collision)/100.0´ might work.

Answer 3

Can You try the following code. I have no prev exp with flash, but seems like You missed something. The iterator xi should take values in range of distance, not only by one axis dx.

        // calculate rotation based on target
        _dx = this.x - _root.hero.x;
        _dy = this.y - _root.hero.y;

        // the iteration is by distance in original article mentioned so
        // keep dist
        //=================================
        _dist = Math.sqrt(_dx*_dx+_dy*_dy);

        // which way to rotate
        _rotateTo = getDegrees(getRadians(_dx, _dy));   

        // keep rotation positive, between 0 and 360 degrees
        if (_rotateTo > barrel.rotation + 90) _rotateTo -= 360;
        if (_rotateTo < barrel.rotation - 90) _rotateTo += 360;

        // ease rotation
        _trueRotation = (_rotateTo - barrel.rotation) / _rotateSpeedMax;

        // update rotation
        barrel.rotation += _trueRotation;   

        wall_collision = 0;

        // xi iterations are to a distance
        //==                  =======
OuterLoop:  for (var xi=1; xi<=_dist; xi++)
        {
            var point_x:Number = this.x + xi*Math.cos(_rotateTo);
            var point_y:Number = this.y + xi*Math.sin(_rotateTo);

            if(_root.wall.hitTestPoint(point_x, point_y, true))
            {
                trace("HIT");
                wall_collision = 100;
                break OuterLoop;
            }
        }

        _root.sight.x = this.x;
        _root.sight.y = this.y;
        _root.sight.rotation += _trueRotation;

        // EDITED AFTER OTHERS SOLVED
        // was
        //_root.sight.alpha = 100 - wall_collision;
        // should be:

        // Alpha changed from [0, 100] scale to [0, 1] scale.
        _root.sight.alpha = (100 - wall_collision) * 0.01;
        // END OF SOLUTION

There is only slight modification to Your original code, marked by preceding //=====

EDIT: And the winner is transparency range. Still, I do recommend to iterate to a distance, not to _dx.