digilabs.com.ar » Actionscript

columnas y filas dinamicas en flash

Andrés Argüello Pitt — Fri, 24 Jun 2011 14:37:36 +0000

Varias veces me encuentro en la posición de tener que acomodar movieclips dinamicamente en el escenario de forma ordenada. Por ejemplo crear una matriz de imagenes para una galleria.
Aqui dejo un pequeno snipet que permite justamente hacer eso

var separacionX:Number = 100;
var separacionY:Number = 50;
 
var fila:Number;
var columna:Number;
var numCols:Number = 3;
var numeroDeItems:uint=100;
 
for (var i:int = 0; i < numeroDeItems; i++)
{
    var _item:Item=new Item();
    fila  = Math.floor(i / numCols);
    columna= i - numCols * fila;
    _items.x = columna *  (separacionX + _item.width);
    _items.y = fila *  (separacionY + _item.height);
    addChild(_item);
}

Eventos personalizado en AS3

Andrés Argüello Pitt — Wed, 06 Oct 2010 16:08:51 +0000

Hasta hace muy poco tiempo siempre que tenia que hacer un script que esperar a que terminara la animacion de un moviclip para hacer otra cosa, lo que hacia era poner una variable en el ultimo frame de la aminacion del movieclip y luego usaba un setInterval o un onEnterFrame y adentro un if y preguntaba si esa variable habia cambiado.
Por ejemplo algo como:
en el ultimo frame de la animación ponía

1 2	_root.termino=true; stop();

y luego en el root ponía

miMovieClip_mc.onEnterFrame = function() {
      if(_root.termino==true) {
             trace ("terminó la animación se prosigue con lo siguiente");
           delete miMovieClip_mc.onEnterFrame;
      }
}

no creo que haya nada de malo en seguir utilizando este método si la aplicación es simple. cuando tenemos varios onEnterFrame o intervals dando vuelta al mismo tiempo.

AS3 se destaca por ser un leguage de programación más robusto y cuenta con todas las propiedades de los leguajes orientados a objetos, y una de esas cosas con los eventos. Por lo cual el dilema anterior queda reducido a simplemente poner un eventListener y luego disparar un evento cuando la animación termina.
Ejemplo:

function terminoAnimacion(event:Event)
{
	trace('terminó la animación');
}
 
miMovieClip_mc.addEventListener("termino", terminoAnimacion);

y luego en el último frame del movieClip disparamos el evento:

1 2	dispatchEvent(new Event("termino")); stop();

mouseX y mouseY relativo a objetos distintos

Andrés Argüello Pitt — Fri, 24 Sep 2010 15:38:00 +0000

Muchas veces necesitamos saber en donde ésta el mouse con respecto a algo. Y en cualquier momento podemos obtener su ubicación relativa al escenario o a un objeto de manera muy simple.

import flash.events.MouseEvent;
 
cuadrado_mc.addEventListener(MouseEvent.MOUSE_OVER, onDown);
function onDown(e:MouseEvent):void
{
    e.target.addEventListener(MouseEvent.MOUSE_MOVE,onMove);
}
 
function onMove(e:MouseEvent):void
{
    trace(e.localX,e.localY);
 
    debug_txt.htmlText="entre del cuadrado\nx: "+e.localX+"\ny: "+e.localY+"\n\nmouse relativo al escenario\nx: "+mouseX+"\ny: "+mouseY;
}

Generar columnas en Flash

Andrés Argüello Pitt — Fri, 24 Sep 2010 11:00:10 +0000

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.

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
...*/

Tierra en paperVision

Andrés Argüello Pitt — Thu, 23 Sep 2010 09:44:22 +0000

Estuve jugando con PV3d en Flash Builder 4 y termine con este experimento. es el tipico Hello World, en este caso el nuestro mundo

El experimento se trató de ver como se comportaban dos texturas una arriba de otra. lo que hice fue crear dos primitivas de, dos esferas, una esfera minimamente más grande que la otra. Luego le apliqué una textura distinta a cada una. finalmente agregue una particulas con un bitmap que simula ser una extrella.

Como toque final puse un onEnterFrame para renderizar la escena, mientras muevo giro en el eje de la Y ambas esferas a velocidades distintas y tambien muevo minimamente las particulas. Es bastante pesado para el procesador, pero no pain no gain.

acá dejo el código:

package {
import flash.display.BitmapData;
import flash.events.Event;
 
import org.papervision3d.core.math.Number3D;
import org.papervision3d.materials.special.MovieParticleMaterial;
 
import org.papervision3d.core.geom.Particles;
import org.papervision3d.core.geom.renderables.Particle;
import org.papervision3d.lights.PointLight3D;
import org.papervision3d.materials.BitmapMaterial;
import org.papervision3d.materials.shaders.GouraudShader;
import org.papervision3d.materials.shaders.ShadedMaterial;
import org.papervision3d.materials.shaders.Shader;
import org.papervision3d.materials.special.BitmapParticleMaterial;
import org.papervision3d.materials.special.ParticleBitmap;
import org.papervision3d.materials.special.ParticleMaterial;
import org.papervision3d.objects.primitives.Sphere;
import org.papervision3d.objects.special.ParticleField;
import org.papervision3d.view.BasicView;
 
[SWF (width="450", height="300", backgroundColor="0x000000", frameRate="30")]
 
public class earth extends BasicView
{
 
public var sphere:Sphere;
public var sphere2:Sphere;
 
public var light : PointLight3D;
 
public var shader : Shader;     
 
public var stars : ParticleField;
public var cloudMaterial : BitmapMaterial;
 
[Embed (source="/../assets/Earth.jpg")]
private var EarthMap : Class;
 
[Embed (source="/../assets/star.png")]
private var particleBitmap : Class;
 
[Embed (source="/../assets/earthcloudmap.png")]
private var CloudMap : Class;
 
public var particles : Particles;
public var particle : Particle
public var counter : int = 0 ;
 
public function earth()
{
super(500,400);
 
var earthbmp:BitmapData = new EarthMap().bitmapData;
var earthmaterial:BitmapMaterial = new BitmapMaterial(earthbmp);
 
var clouds : BitmapData = new CloudMap().bitmapData;
 
// luz
light = new PointLight3D();
light.x = 300;
light.y = 300;
 
// tipo de shader que uso...
 
shader = new GouraudShader(light, 0xFFFFFF,0x404040)
 
// y el material.
var shadedmaterial:ShadedMaterial = new ShadedMaterial(earthmaterial, shader);
shadedmaterial.smooth=true;
 
//creo la primer esfera, la tierra
sphere = new Sphere(shadedmaterial, 150,24,16);
 
//material para la nubes
cloudMaterial = new BitmapMaterial(clouds)
cloudMaterial.smooth = true;
cloudMaterial.doubleSided = false;
 
// creo la segunda esfera
sphere2 = new Sphere(cloudMaterial,160,24,16); 
 
//creo el sistema de particulas
particles = new Particles();
 
//saco el bitmap para crear un material que sera aplicado a cada particula
var particlematerial : BitmapParticleMaterial = new BitmapParticleMaterial(new particleBitmap().bitmapData,0.5,-32,-32);
 
//creo 500 estrellas y la dispongo en el espacio entre 1000 y -500
for(var i : int = 0; i< 500; i++)
{
var particle : Particle = new Particle(particlematerial, 1, (Math.random()*1000) -500, (Math.random()*1000) -500, (Math.random()*3000) -1500);
particles.addParticle(particle);
}
//agrego al sceneario el sistema de particulas
scene.addChild(particles);
 
//agrego la tierra
scene.addChild(sphere);
//agrego las nubes
scene.addChild(sphere2); 
 
//punto de interes de la camara
camera.fov = 30;
 
addEventListener(Event.ENTER_FRAME, enterFrame);             
 
}
 
public function enterFrame(e:Event) : void
{
counter++;
 
sphere.yaw(-1);
sphere2.yaw(-0.5);
particles.yaw(-0.01);
particles.pitch(-0.01);
 
//camera.x = Math.sin(counter*0.02) * 2000;  si quieren que sea automatico en vez de seguir el mouse lo pueden hacer con una onda senoidal
camera.x = ((320-mouseX)*0.01) * 2000;
singleRender();
 
}
 
}
}

Video full screen en flash

Andrés Argüello Pitt — Mon, 20 Sep 2010 08:22:07 +0000

La semana pasada tuve un par de trabajos en los que requeria utilizar un video de flash como fondo y arriba de eso un sitio html puro. Asi que la idea de este mini tutorial es mostrar lo facil que es hacer que el video en flash tome el 100 porciento de la pantalla y se redimencione cuando se cambia el tamano de la pantalla.

1 2	stage.scaleMode = StageScaleMode.NO_SCALE; stage.align = StageAlign.TOP_LEFT;

Con la primer linea especificamos que el tamano de la aplicacion flash tiene que se fija y que se mantiene fija incluso si cambia el tamano del explorador.
La segunda linea especifica que el escenario este alineado en la esquina superior izquierda.

1
2
3

var _netCon :NetConnection = null;
var _netStr :NetStream = null;
var _video :Video = null;

NetConnection es un objecto que podemos describir como un tubo entre el cliente y el servidor.

La clase Video muestra un video en la aplicacion sin incrustarlo en el swf. Digamos lo reproduce en un contenedor mediante streaming.

function SetupNetConnection() {
 _netCon = new NetConnection();
 _netCon.addEventListener(NetStatusEvent.NET_STATUS, NetStatus, false, 0, true);
 _netCon.connect(null);
}

Bueno, yahemso creado la conexion y agredado un listener que monitorea el estado de la conexion. el argumento null significa que no estamos conectando a un Flash media server sino que hacemos streaming de un archivo que reside en un servidor normal.

Ahora vamos a crear el stream que vamos a usar par ver el video mediante el objeto NetConnection y vamos a escuchar su estado mediante listener de ese mismo objeto.

function SetupNetStream() {
 var $customClient:Object = new Object();
$customClient.onMetaData = onMetaData;
_netStr = new NetStream(_netCon);
 _netStr.client = $customClient;
_netStr.addEventListener(NetStatusEvent.NET_STATUS, NetStatus, false, 0, true);
_video = new Video();
 _video.attachNetStream(_netStr);
 _video.smoothing = false;
 addChild(_video);
_netStr.play("video.flv");
 }

La funcion onMetaData va ser llamada tan pronto como el objeto NetStream obtenga informacion del archivo FLV.

 
function onMetaData($info:Object):void {
 
}
 
function NetStatus($e:NetStatusEvent) {
 
switch ($e.info.code)   {
 
case "NetConnection.Connect.Success":
SetupNetStream();
break;
 
case "NetStream.Play.Stop":
_netStr.seek(0);
 }
}
 
 
 
function ResizeAndPosition($e:Event):void
{
_video.width = stage.stageWidth;
_video.height = stage.stageHeight;
}
 
stage.addEventListener(Event.RESIZE, ResizeAndPosition, false, 0, true);
 
ResizeAndPosition(null); 
 
SetupNetConnection();

Y el HTML que contrendria el player sería el siguiente:

Detectar dirección y rotación

Andrés Argüello Pitt — Sat, 11 Sep 2010 10:35:09 +0000

Ayer estuvimos discutiendo con Eduardo un poco sobre su tutorial para detectar la dirección y la rotación en Flash. Su comienzo esta muy bien pero analizamos que tenía un par de fallas. Además él también nombró que le gustaría animar el traslado del avion para que no sea tan brusco, a esto lo realizaremos usando una clase para tweeners.

La primera en realidad no es una falla, sino más bien el deseo que el avión gire hacia la dirección de traslado, lo cual trae un nuevo problema que es hacia donde gira. Por defecto si en Flash sólo se usa rotación el giro que efectúa es en sentido horario, por lo cual a veces esto puede ser muy raro cuando es más rápido girar hacia el otro lado. Hay varias formas de detectar ésto y la que discutíamos es simplemente detectar el angulo de rotación actual restarle 360 y listo. Pero mientras discutiamos con Eduardo que formula utilizar encontré un propiedad/plugin dentro de la clase Tweenmax que no sólo te hace la rotación al ángulo deseado sino que también detecta hacia donde es el giro más corto.

1	TweenMax.to(avion_mc, 0.5, {shortRotation:{rotation:270}});

Con shortRotation nos evitamos tener que hacer el calculo nosotros y decide hacer el giro en sentido horario o antihorario según cual sea más corto

Ahora el otro problema es que cuando movemos el mouse no lo hacemos en un movimiento perfecto hacia arriba o abajo o hacia los laterales, en realidad siempre existen una componente hacia arriba, abajo o laterales . una especie de ruido.
Para solucionar este problema empecé por detectar manualmente en donde se encuentra el mouse y hacia donde se mueve. Luego hago los cambios de giro solamente cuando el movimiento es 100% hacia los costados o 100% hacia arriba o abajo. De esta forma se evita que haya pequeño intentos de cambiar el gira cuando en realidad es sólo ruido.

El código completo es el siguiente:

import com.greensock.*;
import com.greensock.easing.*;
 
function Start()
{
stage.addEventListener(MouseEvent.MOUSE_MOVE, CheckDirection);
}
 
Start();
 
var prevX = 0;
var prevY = 0;
var curX = 0;
var curY = 0;
var dirX:String = "";
var dirY:String = "";
 
function CheckDirection(e:MouseEvent)
{
var dirHorizontal:String = obtenerDireccionHorizontal();
var dirVertical:String = obtenerDireccionVertical();
trace("movimiento en X : " + dirHorizontal + ", movimiento en Y : " + dirVertical);
TweenMax.to(avion_mc, 1, { x:mouseX,y:mouseY});
hacerGiro(dirHorizontal,dirVertical);
e.updateAfterEvent();
}
 
function hacerGiro(dirHorizontal,dirVertical)
{
if (dirHorizontal == 'derecha' && dirVertical == 'none')
{
TweenMax.to(avion_mc, 0.5, {shortRotation:{rotation:90}});
}
else if (dirHorizontal=='izquierda' && dirVertical == 'none')
{
TweenMax.to(avion_mc, 0.5, {shortRotation:{rotation:270}});
}
if (dirVertical == 'arriba' && dirHorizontal == 'none')
{
TweenMax.to(avion_mc, 0.5, {shortRotation:{rotation:0}});
}
else if (dirVertical=='abajo' && dirHorizontal == 'none')
{
TweenMax.to(avion_mc, 0.5, {shortRotation:{rotation:180}});
}
}
 
function obtenerDireccionHorizontal():String
{
 
prevX = curX;
curX = stage.mouseX;
 
if (prevX > curX)
{
dirX = "izquierda";
}
else if (prevX < curX)
{
dirX = "derecha";
}
else
{
dirX = "none";
}
return dirX;
}
 
function obtenerDireccionVertical():String
{
prevY = curY;
curY = stage.mouseY;
if (prevY > curY)
{
dirY = "arriba";
}
else if (prevY < curY)
{
dirY = "abajo";
}
else
{
dirY = "none";
}
return dirY;
}

Para que les funcione tienen que bajar la clase tweenMax para AS3 desde: http://www.tweenmax.com

Acá el ejemplo funcionando:

noten que cambié la resolución a la misma resolución del iPhone, el próximo post será como portar esto a una aplicación de iPhone.

Detectar dirección con ActionScrip 2

Eduardo Martin — Thu, 09 Sep 2010 02:03:50 +0000

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.

Un sonido luego de otro

Andrés Argüello Pitt — Sat, 19 Jun 2010 10:31:27 +0000

El año pasado hice un trabajo donde se necesitaba que se reproducieran unas imágenes y al mismo tiempo se escuchara una voz en voz describiendo la imagen.
El tema que eran varia galerías que eran cambiadas dinámicamente por lo que se requería que ésta pseudo película se generara en tiempo de ejecución.
El tema estaba en precargar todas las imágenes y todas los sonidos para que no haya pausas entre imagen e imagen.
Precargar la imágenes es relativamente facil ya que podes cargarlas usando un loadClip ya que son guardadas automáticamente en el caché.
El tema son los sonidos, como asegurarse que los sonidos son precargados de forma que no haya pausas. Hay un par de formas de hacerlo la que me resultó más práctica a mi fue:

La forma normal sería, manual y estática sería:

import flash.media.Sound;
import flash.media.SoundChannel;
 
var mySoundOne:Sound = new SoundOne();
var mySoundTwo:Sound = new SoundTwo();
var mySoundThree:Sound = new SoundThree();
 
var mySoundChannel:SoundChannel = mySoundOne.play();
mySoundChannel.addEventListener(Event.SOUND_COMPLETE, sound_1_Complete);
 
var mySoundChannel2:SoundChannel;
var mySoundChannel3:SoundChannel;
 
function sound_1_Complete(event:Event):void {
    trace("one complete");
    mySoundChannel2 = mySoundTwo.play();
    mySoundChannel2.addEventListener(Event.SOUND_COMPLETE, sound_2_Complete);
}
 
function sound_2_Complete(event:Event):void {
    trace("two complete");
    mySoundChannel3 = mySoundThree.play();
    mySoundChannel3.addEventListener(Event.SOUND_COMPLETE, sound_3_Complete);
}
 
function sound_3_Complete(event:Event):void {
    trace("three complete");
}

Hasta acá todo fácil, lo que fue una novedad para mi es que es posible meter objetos dentro de arrays, por lo que cree un array con sonidos (objetos) adentro y fui cargando un sonido después del otro, de forma que era automatizado, dinámico y que podía ser cambiado en tiempo de ejecución sin problemas.

var sounds:Array = [new SoundOne(), new SoundTwo(), new SoundThree()];
 
var channels:Array;
 
channels[0] = Sound(sounds[0]).play();
 
SoundChannel(channel[0]).addEventListener(Event.SOUND_COMPLETE, playNext);
 
function playNext(e:Event):void
 
{
 
var index:Number = channels.indexOf(e.currentTarget);
 
trace("played sound " + (index + 1));
 
if(index &lt; sounds.lenth - 1)
 
{
 
index++;
 
channels[index] = Sound(sounds[index]).play();
 
SoundChannel(channels[index]).addEventListener(Event.SOUND_COMPLETE, playNext);
 
}
 
}
sounds.push(new SoundFour()); // sólo habría que asegurarse de llamar a esto antes que el sonido cuatro termine de reproducirse

Animando huesos con AS3 (bones y actionscript 3)

Andrés Argüello Pitt — Thu, 03 Jun 2010 01:13:31 +0000

Éste tutorial es para dar una idea básica de lo que se puede hacer con los huesos y la cinemática inversa. Lo interesante es poder mover éstos huesos por código y así reaccionar en runtime de acuerdo a posición del mouse, ingreso del teclado o como abarca éste tutorial a la música.
Ejemplo final:

Lo primero es elegir un objeto que querramos animar, en mi caso la mascota de Homestar Runner, que lo peuden bajar de brandsoftheworld. Luego tenemos que convertir en movieclips cada sección de nuestro objeto, por ejemplo: la cabeza, el tronco, la pierna derecha, la pierna izquierda.
Luego elegimos la herramienta “bones” (x) y empezamos a unir nuestros objetos.

Luego seleccionamos el frame que contiene nuestros moviclips unidos por los huesos que creamos y veremos que en el panel propiedades aparece el nombre del esqueleto que acabamos de crear. Ahí podemos darle un nuevo nombre a todo nuestro esqueleto, yo voy a utilizar el que me tocó por defecto.

Es importante que seleccionar el frame y no el moviclip ya que si seleccionamos un moviclip accedemos a las propiedades del hueso en sí pero no del esqueleto completo.

También es importante cambiar y el Type de authotime a runtime, lo que hace que los huesos se van a animen en tiempo de ejecución en vez de ser animados con tween o cuadro por cuadro dentro de Flash. Luego de tener el nombre del esqueleto si pasamos a seleccionar los huesos que queremos mover y le damos nombres, también en ésta parte podemos ajustar los ángulos que vamos a permitir que se mueva y varias otras propiedades, yo no cambié nada pero los resultados pueden variar.

Por último la parte del código.
Básicamente lo que tenemos que hacer es registrar el esqueleto y luego ligar a éste esqueleto los huesos que a su vez tienen dos puntos por lo cual tenemos que decir cual de dichos puntos queremos mover y lo podemos hacer en cualquier eje: x,y o z. El registro del esqueleto se hace una vez, y luego tenemos decidir cuantos huesos se van a mover.
En este caso lo que voy a hacer es cargar un sonido, analizar su espectro y mover el pie izquierdo con lo que haya en el canal izquierdo de la música y luego lo mismo con el derecho.

var tree:IKArmature = IKManager.getArmatureByName("Armature_5");
var right_leg:IKBone = tree.getBoneByName("ikBoneName9");
var left_leg:IKBone = tree.getBoneByName("ikBoneName10");
var cabeza:IKBone = tree.getBoneByName("ikNode_6");
 
// tailJoint mueve e punto del hueso, si queremos mover la cabeza del hueso debemos usar headJoint
 
//para la pierna derecha
var rtJ:IKJoint = right_leg.tailJoint;
var rposT: Point=rtJ.position;
var rikMover:IKMover = new IKMover(rtJ, rposT);
 
//para la pierna izquiera
var ltJ:IKJoint = left_leg.tailJoint;
var lposT: Point=ltJ.position;
var likMover:IKMover = new IKMover(ltJ,lposT);
 
// cargo un sonido para analizar su espectro y mover los huesos según éste.
var s:Sound = new Sound();
s.load(new URLRequest("http://digilabs.com.ar/wp-content/uploads/2010/06/loop.mp3"));
var sc:SoundChannel;
sc = s.play(0, 1000);
 
this.addEventListener(Event.ENTER_FRAME, aMoverLosHuesos);
 
function aMoverLosHuesos(eventArgs:Event)
{
	rposT.x=110+(sc.rightPeak* - 20); //110 es donde esta el punto en reposo
        //y 20 son la cantidad de pixeles que quiero que se mueva que es multiplicado por algo entre 0 y 1.
	lposT.x=50+(sc.leftPeak* + 30);
	rikMover.moveTo(rposT);
	likMover.moveTo(lposT);
}

Lo único que le agregué a mi ejemplo final fue un botón de start/stop para no volver loco a los que visiten digilabs
Como ejercicio estaría bueno agregar un hueso desde el cuello a la punta de la cabeza ya animar la cabeza también. Para ésto hace falta agregar un movieclip transparente en la punta de la cabeza de lo contrario no sería imposible “tirar un nuevo hueso”. Otra cosa seria analizar bien el espectro del sonido cargado y usar los bajos para mover ciertas partes y los altos para otras.