Generación de partículas (III)

Inicio

capítulo todos los objetos implicados describirán un nuevo tipo de movimiento: el armónico simple.

Seguramente todos conocen que la cuerda de una guitarra al vibrar, las ondas sonoras, electromagnéticas y las corrientes alternas efectúan un movimiento ondulatorio que puede representarse como un sinusoide si trazamos dicho comportamiento en un eje coordenado rectangular, donde el eje Y indica la posición con respecto al tiempo rotulado en X. Veremos con detalle mediante un simple ejemplo:

El péndulo del «reloj» de la figura 0x01 oscila durante diez segundos con la posición de equilibrio en SO , sin acción de fuerzas externas que puedan interferir en el movimiento. La analogía entre el caso real y el análisis gráfico podría establecerse si modelamos valores extremos -positivos y negativos- en el eje Y que correspondan al desplazamiento máximo del péndulo -hacia la izquierda y la derecha-, respectivamente. Luego, si en intervalos de tiempo suficientemente pequeños dibujamos puntos a lo largo del eje X que correspondan al valor posicional que tenga el péndulo en dichos instantes, resultará un gráfico similar al de la figura 0x02:

Como era de esperar, se producen curvas similares a la función seno, donde valles y crestas coinciden en sus puntos críticos con el valor límite de la oscilación del péndulo del modelo real. En Adobe Flash podemos generar comportamientos similares, adaptando las interpretaciones físicas de dichos fenómenos a la metodología del ActionScript 2.0.

Pues comencemos a establecer que un oscilador armónico simple cumple con un conjunto de propiedades que definen su curso a través del tiempo. Los tres parámetros fundamentales con los que debemos lidiar para lograr que una partícula describa tal movimiento son:

Amplitud: viene dada por el valor modular de Sm.
Longitud de onda: distancia que separa dos puntos en fase adyacentes.
Velocidad de fase: rapidez con que la onda se desplaza.

La fase de una onda puede comprenderse, básicamente, como su estado de movimiento en función del tiempo transcurrido y nos puede servir de mucha utilidad para la modelación de nuestro problema. Sabemos, gracias a los físicos, que la posición de la onda en el eje Y, en función de la posición en X y del tiempo, viene dada por la fórmula:

Y(x, t) = Amplitud * sen ( (2 * π) / Longitud de onda ) * ( x – Velocidad de fase * t )

Adaptando dicha fórmula para nuestros intereses, tenemos que en el eje X cada partícula generada va a incrementarse en función del tiempo en el valor phase_velocity y para el eje Y, la partícula va a describir un movimiento amplitude * sen ( ( 2 * π * _increment) / wave_length). Ese valor incremental añadido tiene una función importante a la hora de plantear el problema sobre ActionScript 2.0 o cualquier otro lenguaje de programación similar.

Ya resuelta la parte inicial, comenzaremos a convertir en un MovieClip un círculo diminuto trazado sobre el escenario. Luego le asignaremos dentro de la ventana Biblioteca un nombre e identificador point, vinculado a la clase Particle. Enseguida crearemos en File » New » ActionScript File un nuevo documento que guardaremos en la misma carpeta del proyecto, y escribiremos en él la clase Particle, que hereda de la clase MovieClip:

class Particle extends MovieClip{
  private var amplitude:Number = 0;
  private var wave_length:Number = 0;
  private var phase_velocity:Number = 0;
  private var _increment:Number = 0; // Incremento del ángulo (en radianes)
  private var init_y:Number = 0; // Posición inicial en el eje Y

  // Constructor
  public function Particle(){}

  public function onEnterFrame():Void{
    this._x += phase_velocity;
    this._y = init_y + amplitude * Math.sin((2 * Math.PI * _increment) / wave_length);
    _increment++;
    if(this._x > Stage.width){
      this.removeMovieClip(); // Elimina la partícula cuando sale del escenario 
    }
  }

  // Amplitud 
  public function setAmplitude(_amplitude:Number):Void{
    this.amplitude = _amplitude;
  }
  public function getAmplitude():Number{
    return this.amplitude;
  }

  // Longitud de onda
  public function setWave_length(_wave_length:Number):Void{
    this.wave_length = _wave_length
  }
  public function getWave_length():Number{
    return this.wave_length;
  }

  // Velocidad de fase 
  public function setPhase_velocity(_phase_velocity:Number):Void{
    this.phase_velocity = _phase_velocity;
  }
  public function getPhase_velocity():Number{
    return this.phase_velocity;
  }
}

Ya tenemos lista la clase, con valores encapsulados, polimorfismo aplicado al onEnterFrame de la clase MovieClip y los métodos para pasar valores a los futuros objetos de Particle. Luego, vamos al documento de Flash, quitamos el pequeño círculo del escenario y escribimos en el primer fotograma lo siguiente:

var init_x:Number = 0;
var init_y:Number = Stage.height * 2 / 5;
var input_amplitude:Number = 20;
var input_wave_length:Number = 100;
var input_phase_velocity:Number = 1;
var counter:Number = 2; // contador de partículas generadas

onEnterFrame = function(){
  // generar partícula
  attachMovie("point", "point" + counter, getNextHighestDepth() + counter,{_x:init_x, _y:init_y, init_y:init_y});
  // almacenar la ruta de la última partícula generada
  current_point = eval("_root.point" + counter);
  current_point.setAmplitude(input_amplitude);
  current_point.setWave_length(input_wave_length);
  current_point.setPhase_velocity(input_phase_velocity);
  counter++; // vamos, que venga la próxima partícula!
}

Cuando reproduzcamos esta película Flash, las partículas se generarán a una velocidad por defecto de 12 fotogramas por segundo. Si disminuimos demasiado el valor de la longitud de onda, la mayor parte de los microprocesadores se verán forzados por la carga de procesamiento y disminuirá el rendimiento del sistema operativo. Es necesario, para que corra bien nuestro Flash, configurar adecuadamente los parámetros input_amplitude, input_wave_length e input_phase_velocity, que son pasados a cada objeto en tiempo de ejecución. En el siguiente Flash -similar al que usted obtendrá- se pueden evaluar cada uno de esos parámetros directamente a través de la interfaz gráfica (para verlo correctamente, su navegador debe tener instalado el complemento Flash Player 8 o superior; es recomendable no insertar una amplitud superior a 50 píxeles):

Próximamente estaremos resolviendo sistemas más complejos de movimiento. Los interesados vayan pensando en el típico juego de matar moscas, donde cada insecto realiza una trayectoria diferente de vuelo no rectilíneo y no uniforme. A eso se le puede agregar también velocidad y dirección del viento, que afecte el vuelo de cada mosca.