Форум Flasher.ru - Странные глюки.

Здравствуйте.
Сегодня ночью наткнулся на целый ряд не понятных мне багов. Когда трасировка к примеру

Код:

course.controlpoint[0][0]==Math.floor(course._x)

показывала false при course.controlpoint[0][0]=163 && Math.floor(course._x)=163. Но это еще не всё. Попрошу лучше взглянуть на код. Так как при выполнении одного условия в строчке 56 просчитываются довольно большое количество итераций в пустую. Это можно увидеть при снятии закоментированных трейсеров.
Дальше идёт код, правда немного не красивый но я не успел еще привести его до толку. Но больше всего интересует такой вопрос с свойствами _х и _у с аналогичными course.controlpoint[0][0] и course.controlpoint[0][1] данными, когда там одинаковые числа а выводит false, причём если не использовать Math.floor то вообщепроисходить всеголишь 1 итерация.

Код AS1/AS2:

//import flash.display.Graphics;

 

class Vector2D

{

 

                private var _x:Number;

                private var _y:Number;

 

                public function Vector2D(x:Number,y:Number)

                {

                        _x = x;

                        _y = y;

                }

 

                public function draw(graphics:MovieClip, color):Void

                {

                        graphics.lineStyle(0, color);

                        graphics.moveTo(0, 0);

                        graphics.lineTo(_x, _y);

                }

 

                public function clone():Vector2D

                {

                        return new Vector2D(x, y);

                }

 

                public function zero():Vector2D

                {

                        _x = 0;

                        _y = 0;

                        return this;

                }

 

                public function isZero():Boolean

                {

                        return _x == 0 && _y == 0;

                }

 

                public function set length(value:Number):Void

                {

                        var a:Number = angle;

                        _x = Math.cos(a) * value;

                        _y = Math.sin(a) * value;

                }

                public function get length():Number

                {

                        return Math.sqrt(lengthSQ);

                }

 

                public function get lengthSQ():Number

                {

                        return _x * _x + _y * _y;

                }

 

                public function set angle(value:Number):Void

                {

                        var len:Number = length;

                        _x = Math.cos(value) * len;

                        _y = Math.sin(value) * len;

                }

                public function get angle():Number

                {

                        return Math.atan2(_y, _x);

                }

 

                public function set corner(value:Number):Void

                {

                        var len:Number = length;

                        _x = Math.cos(value*Math.PI/180) * len;

                        _y = Math.sin(value*Math.PI/180) * len;

                }

 

                public function get corner():Number

                {

                        return angle * 180 / Math.PI;

                }

 

                public function normalize():Vector2D

                {

                        if(length == 0)

                        {

                                _x = 1;

                                return this;

                        }

                        var len:Number = length;

                        _x /= len;

                        _y /= len;

                        return this;

                }

 

                public function truncate(max:Number):Vector2D

                {

                        length = Math.min(max, length);

                        return this;

                }

 

                public function reverse():Vector2D

                {

                        _x = -_x;

                        _y = -_y;

                        return this;

                }

 

                public function isNormalized():Boolean

                {

                        return length == 1.0;

                }

 

                public function dotProd(v2:Vector2D):Number

                {

                        return _x * v2.x + _y * v2.y;

                }

 

                public function crossProd(v2:Vector2D):Number

                {

                        return _x * v2.y - _y * v2.x;

                }

 

 

                public static function angleBetween(v1:Vector2D, v2:Vector2D):Number

                 {

                        if(!v1.isNormalized()) v1 = v1.clone().normalize();

                        if(!v2.isNormalized()) v2 = v2.clone().normalize();

                        return Math.acos(v1.dotProd(v2));

                 }

 

                  public static function cornerBetween(v1:Vector2D, v2:Vector2D):Number

                 {

                        return angleBetween(v1,v2) * 180 / Math.PI;

                 }

 

                public function sign(v2:Vector2D)

                {

                        return perp.dotProd(v2) < 0 ? -1 : 1;

                }

 

                public function get perp():Vector2D

                {

                        return new Vector2D(-y, x);

                }

 

                public function dist(v2:Vector2D):Number

                {

                        return Math.sqrt(distSQ(v2));

                }

 

                public function distSQ(v2:Vector2D):Number

                {

                        var dx:Number = v2.x - x;

                        var dy:Number = v2.y - y;

                        return dx * dx + dy * dy;

                }

 

                public function add(v2:Vector2D):Vector2D

                {

                        return new Vector2D(_x + v2.x, _y + v2.y);

                }

 

                public function subtract(v2:Vector2D):Vector2D

                {

                        return new Vector2D(_x - v2.x, _y - v2.y);

                }

 

                public function multiply(value:Number):Vector2D

                {

                        return new Vector2D(_x * value, _y * value);

                }

 

                public function divide(value:Number):Vector2D

                {

                        return new Vector2D(_x / value, _y / value);

                }

 

                public function equals(v2:Vector2D):Boolean

                {

                        return _x == v2.x && _y == v2.y;

                }

 

                public function set x(value:Number):Void

                {

                        _x = value;

                }

                public function get x():Number

                {

                        return _x;

                }

 

                public function set y(value:Number):Void

                {

                        _y = value;

                }

                public function get y():Number

                {

                        return _y;

                }

 

                public function toString():String

                {

                        return "[Vector2D (x:" + _x + ", y:" + _y + ")]";

                }

}

и в самом флеше поместите небольшой мувик с назначенным ему "ship" идентификатором.

Код AS1/AS2:

import Vector2D;

 

var t:MovieClip = _root.createEmptyMovieClip("triang_mc", 1);

        thickness = 1; 

        lineColor = 0xff0000; 

        alpha = 100;

 

        triang_mc.lineStyle(thickness, lineColor, alpha);

 

ship.m=20;

ship.speed=20;

ship.stopl=30;

ship.radius=180/ship.m;

 

triang_mc.moveTo(ship._x, ship._y);

 

X=ship._x+Math.cos(Math.PI/180*(ship._rotation+90))*ship.radius;

Y=ship._y+Math.sin(Math.PI/180*(ship._rotation+90))*ship.radius;

triang_mc.lineTo(X, Y);

var course:MovieClip = new MovieClip();

 

course.axis = new Vector2D(Math.cos(Math.PI/180*ship._rotation),Math.sin(Math.PI/180*ship._rotation));

 

course.target = new Vector2D(dot._x-ship._x,dot._y-ship._y);

 

triang_mc.lineStyle(0, 0xFF0000);

triang_mc.moveTo(ship._x, ship._y);

 

BuildRoute = function()

{

                r++;

 

                course.target.x=course.tx-course._x;

                course.target.y=course.ty-course._y;

 

                //trace(Vector2D.cornerBetween(course.route,course.target));

 

                if (Vector2D.cornerBetween(course.route,course.target)>course.m)

                {

 

                        course.route.corner+=course.shift*course.m;

                        course._rotation=course.route.corner;

 

                } else

                {

                        course.route=course.target;

                        course._rotation=course.target.corner;

                }

 

                course._x+= (course.target.length>course.speed) ? Math.cos(Math.PI/180*course._rotation)*course.speed : course.target.x;

                course._y+= (course.target.length>course.speed) ? Math.sin(Math.PI/180*course._rotation)*course.speed : course.target.y;

 

                course._x=Math.floor(course._x);

                course._y=Math.floor(course._y);

 

                if ((course.controlpoint[0][0]==Math.floor(course._x) && course.controlpoint[0][1]==Math.floor(course._y)) || (Vector2D.cornerBetween(course.route,course.axis)<course.m && !course.route.equals(course.target)))

                { 

 

 

                        //triang_mc.lineTo(course._x, course._y);

                        course.speed-=1;

//trace('Speed:'+course.speed);

                        course.controlpoint.splice(1);

                        course.route.x=course.axis.x;

                        course.route.y=course.axis.y;

                        course.route = course.axis.clone();

                        course.route.corner+=course.shift;

                        course._x=Math.floor(ship._x);

                        course._y=Math.floor(ship._y);

 

                } else

                {

                        if (course.target.length<course.speed)

                        {

                                if (course.target.equals(course.route))

                                {

                                        course.controlpoint.push([course._x, course._y,course._rotation]);

 

                                        return false;

                                } 

                                else

                                {

                                        course.speed-=1;

 

                                        course.controlpoint.splice(0);

                                        course.route.x=course.axis.x;

                                        course.route.y=course.axis.y;

                                        course.route = course.axis.clone();

                                        course.route.corner+=course.shift;

                                        course._x=Math.floor(ship._x);

                                        course._y=Math.floor(ship._y);

 

                                        /*/triang_mc.clear();

                                        triang_mc.lineStyle(0, 0xFF0000);

                                        triang_mc.moveTo(course.controlpoint[0][0],course.controlpoint[0][1]);*/

                                }

 

                        } else

                        {

                                course.controlpoint.push([course._x, course._y,course._rotation]);

                                //triang_mc.lineTo(course._x, course._y);

                        }

 

                }

                return true;

}

 

function traceRoute()

{

        triang_mc.lineStyle(0, 0xFF0000);

        triang_mc.moveTo(course.controlpoint[0][0],course.controlpoint[0][1]);

 

        for (step=1; step< course.controlpoint.length; step++)

        {

                triang_mc.lineTo(course.controlpoint[step][0],course.controlpoint[step][1]);

        }

}

 

_root.bufferT = getTimer();

_root.onMouseDown = function()

{

        delete ship.onEnterFrame;

 

        if (getTimer()-_root.bufferT>500)

        {

                ship._x= Math.floor(ship._x);

                ship._y= Math.floor(ship._y);

                course.tx = Math.floor(_xmouse);

                course.ty = Math.floor(_ymouse);

                course._x = ship._x;

                course._y = ship._y;

                course._rotation = ship._rotation;

                course.controlpoint = new Array();

 

                for (prop in ship)

                {

                        course[prop]=ship[prop];

                }

 

                course.axis.x=Math.cos(Math.PI/180*course._rotation);

                course.axis.y=Math.sin(Math.PI/180*course._rotation);

 

                course.target.x=course.tx-course._x;

                course.target.y=course.ty-course._y;

 

                course.axis.length=1;

 

                course.route = course.axis.clone();

 

                if (Vector2D.cornerBetween(course.axis,course.target)>=course.m)

                {

                        course.shift = 1;

 

                        course.route.corner+=course.shift;

 

                        if (Vector2D.cornerBetween(course.route,course.target)>Vector2D.cornerBetween(course.axis,course.target))

                        {

                                course.shift*=-1;

                        }

                } else course.shift = 0;

 

                course.route.x=course.axis.x;

                course.route.y=course.axis.y;

 

                course.controlpoint.push([course._x, course._y,course._rotation]);

 

                r = 0;

                while (BuildRoute());

 

                trace('Search iteration :: '+r);

        } else

        {

                traceRoute();

                delete ship.onEnterFrame;

                //trace(course.controlpoint);

                ship.dx=(course.controlpoint[1][0]-ship._x)/10;

                ship.dy=(course.controlpoint[1][1]-ship._y)/10;

                ship.dr=(course.controlpoint[1][2]-ship._rotation)/10;

                ship.s=0;

                ship.st=1;

                ship.onEnterFrame = function()

                {

                        //trace(course.controlpoint[++ship.st][0]);

                        this._x+=this.dx;

                        this._y+=this.dy;

                        this._rotation+=this.dr;

                        if (++this.s==10)

                        {

                                this.s=0;

                                this.dx=(_root.course.controlpoint[++this.st][0]-this._x)/10;

                                this.dy=(_root.course.controlpoint[this.st][1]-this._y)/10;

                                this.dr=(_root.course.controlpoint[this.st][2]-this._rotation)/10;

                        }

                }

        }

        _root.bufferT = getTimer();

        //traceRoute();

}

предыдущая тема http://www.flasher.ru/forum/showthread.php?t=151244