Aca dejo un pequeño tip de como generar columnas en flash facilmente.
La idea en usar un for pero no necesitar de hacer for añidados o usar contadores sino hacer todo en una sola línea usando el símbolo %. Con este “truquico” cada vez que i es divisible por 10 la vuelve cero de forma que el contador en x de este ejemplo decrementa desde -250 de 50 en 50. Lo único valores que peude tomar x son entre -250 y 250 y varía de 50 en 50. Usando este método es muy fácil generar una grilla donde posicionamos elementos.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

for(var i : int = 0; i< 100; i++){
trace ('x: '+((i%10)-5)*50);
trace('y: '+ ((i/10)-5)*50);
}
//los traces de este ejemplo sería:
/*
x: -250
y: -250
x: -200
y: -245.00000000000003
x: -150
y: -240
x: -100
y: -235
x: -50
y: -229.99999999999997
x: 0
y: -225
x: 50
y: -220.00000000000003
x: 100
y: -215
x: 150
y: -210
x: 200
y: -204.99999999999997
x: -250
y: -200
x: -200
y: -195
x: -150
y: -190
x: -100
y: -185
x: -50
y: -180
x: 0
y: -175
x: 50
y: -170
x: 100
y: -165
x: 150
y: -160
x: 200
...*/

Si lo que intentan es detectar hacia que dirección va el cursor del mouse utilizando ActionScript2, les recomiendo utilizar un método que poco conocía que es nativo de Flash, su nombre es “watch“. Esta función analizar una variable y devuelve dos valores uno nuevo “newVal” y otro viejo “oldVal“,  lo cual nos facilita el trabajo si tenemos que desarrollar una pelicula que detecte si el mouse va hacia la derecha o hacia izquierda, arriba o abajo, este método es muy interesante ya que nos permitiría saber si los valores en x e y se incrementan o disminuye lo cual con un simple if podríamos saber hacia donde se dirige el cursor. Esta función también puede servir para activar alertas, cuando una variable cambia, se analiza con watch y cuando se cumple una condición se activa una alarma, se ejecuta una función o simplemente se activa una animación.

Esto también se puede hacer con listeners, pero es mas complejo ya que hay que armar la función que permite comparar el valor viejo con el valor nuevo de la variable mientras cambia. No les aconsejo utilizar onEnterFrame ya que consume muchos recursos.

Ejempo:

Codigo:

Mouse.hide();
posX = function (dx, oldVal, newVal) {
    if (oldValnewVal) {
        trace("Izquierda");
        avion_mc._rotation = -90;
    }
    return newVal;
};
posY = function (dy, oldVal, newVal) {
    if (oldValnewVal) {
        trace("rriba");
        avion_mc._rotation = 360;
    }
    return newVal;
};
 
this.watch("dirx",posX);
this.watch("diry",posY);
 
this.onMouseMove = function() {
    avion_mc._x = _xmouse;
    avion_mc._y = _ymouse;
    dirx = _xmouse;
    diry = _ymouse;
 
};

Para los que estan trabajando con As3, el método watch no existe mas, por lo cual les dejo una solución AQUI

Clase:

package
{
   import flash.events.Event;
   import flash.events.EventDispatcher;
   public class Model extends EventDispatcher
   {
       public static const VALUE_CHANGED:String = 'value_changed';
       private var _number:Number = Number;
       public function Model():void
       {
           trace('The model was instantiated.');
       }
       public function set number(newNb:Number):void
       {
          _number=newNb;
          this.dispatchEvent(new Event(Model.VALUE_CHANGED));
       }
       public function get number():Number
      {
          return _number;
 
      }
   }
}

Modo de uso:

var objectToWatch:Model = new Model();
objectToWatch.addEventListener(Model.VALUE_CHANGED, onValuedChanged);
 
function onValuedChanged(e:Event) {
   //do what you need here
}

Espero que les sea útil, la próxima me gustaría completar la pelicula de arriba con algo de trigonometría para simular 100% la dirección.

me encantan la librerías de cualquier lenguaje sobre todo las de Flash. Tweenlite es mi librería por defecto que utilizo en el 90 por ciento de mis proyectos. Esta semana empecé a usar una nueva librería que tiene mas utilidades y no se especializa en animaciones si no que se utiliza para hacer la carga de archivos externos. Lo que más me gustó de esta librería es que permite hacer optimizaciones de memoria en cualquier momento, cosa que nos podría ser útil en caso de estar desarrollando alguna aplicación para dispositivos móviles donde la memoria es acotada. Otra ventaja es que viene en dos gustos para los clásicos AS2 y para aquellos más atrevidos AS3.

Más información en:

http://as3.casalib.org/releases/1.2.1/docs/

Siguiendo con formulas útiles de mi post anterior y estudiando un poco algoritmos Euclidianos, cree un par de funciones para saber cual es la relación de aspecto de una imagen.

function getMCD(w:int, h:int):int{ 
return ((h != 0) ? arguments.callee(h, w % h): w); 
}
 
function getAspectRatio(w:uint, h:uint):String{ 
var mcd:Number = getMCD(w, h);
return [(w / mcd), (h / mcd)].join(":"); 
}

y estos son algunos testeos:

trace (getAspectRatio(320, 240)); // 4:3 
trace (getAspectRatio(540, 480)); // 9:8 
trace (getAspectRatio(550, 400)); // 11:8

Math.random() es una función super utilizada dentro de flash. Pero mucho más versátil es poder elegir el rango en el que nos devuelve dicho numero aleatorio, por ejemplo: si queremos un numero aleatorio entre el 5 y el 13. Eso se Puede solucionar fácil haciendo min + (max – min) * Math.random();

function randomMinMax( min:Number, max:Number ):Number {
return min + (max - min) * Math.random(); 
}
var miNumeroAleatorio:Number=randomMinMax(5,13);
trace(miNumeroAleatorio);

Se que no es una maravilla pero es muy útil y la utilizo aunque sea una vez por semana en mis proyectos.