/*
* Rastros
* 
* Rastros.
* Metodos estaticos para la crecion de rastros en OmegaFenix.
* El objeto recibe un clip donde se crearan los rastros y cada llamada
* va creando una parte del rastro. 
* 
* El rastro puede constar de fases, el comportamiento de cada fase se da por los valores en los arreglos.
* 
* Proyecto OmegaFenix V2.
* 
* Autor: Miguel Angel Lopez Saenz.
*/


class Rastros{
	
	
	//variables de clase
	static var NOMBRE_OBJETO:String = "rastro";//nombre de los objeto creados
	
	
	
	//variables de instancia
	private var __obj:MovieClip;//clip padre donde se crearan los clips vacios para el rastro.
	private var __pos:Array;//coordenadas y de los ultimos trasos. los datos pares representan x, los impares y.
	private var __trazos:Number;//numero de trasos que se dan.
	private var __velocidadX:Number;//velocidad inicial de caida de los rastros
	private var __velocidadY:Number;
	private var __aceleracionX:Number;//aceleracion por frame que van tomando
	private var __aceleracionY:Number;
	private var __fases:Number;//numero de fases en la animacion de los rastros.
	private var __color:Number;//color de los trazos
	private var __duracion:Array;//arreglo que indica las duraciones de las fases
	private var __duracionTotal:Number//Duracion total del rastro
	private var __grosorInicial:Number;//grosor inicial (duhh) se define por el primer valor del arreglo de grosores
	private var __alphaInicial:Number;//alpha inicial (duhh) se define por el primer valor del arreglo de alphas
	private var __grosorAumento:Array;//almacena los aumento de cada fase
	private var __alphaAumento:Array;//almacena los aumento de cada fase
	
	
	
	
	/*
	* Constructor Base
	* Asigna valores a las variables de instancia
	* 
	* Parametros:
	* obj - objeto donde se crearan los clips que contienen los rastros.
	* pos - Arreglo de posiciones. Cada par de arreglo representa una coordenada (x,y), por lo que la cordenanda n esta constituida por (2*n, 2*n +1).  El tamano del arreglo debe de ser trazos*2.
	* trazos - cantidad de lineas que se trazaran por frame.
	* fases - cantidad de secuencias de animacion que se tendran.
	* col - color de las lineas, debe de estar en hex.
	* duracion - arreglo que contiene la duracion de cada una de las fases.  El tamano del arreglo debe ser fases.
	* grosor - arreglo con los grosores en cada una de las fases, el grosor inicial de una fase n esta en la posicion n, mientras que el final en la posicion n+1.  El tamano del arreglo debe de ser fases+1.
	* alpha - arreglo con las alphas en cada fase. El funcionamiento es igual que el de grosor.
	* 
	* Nota:
	* Lo arreglo usados como paramentos no seran copiados, por lo que
	* la modificacion externa de estos resultara en comportamientos 
	* erroneos de la clase. Se recomienda que cada ves se utilizen
	* arreglos nuevos.
	*/
	public function Rastros(obj:MovieClip, pos:Array, trazos:Number, fases:Number, col:Number, duracion:Array, grosor:Array, alpha:Array){
		__obj = obj;
		__pos = pos;
		__trazos = trazos;
		__velocidadX = 0;
		__velocidadY = 0;
		__aceleracionX = 0;
		__aceleracionY = 0;
		__fases = fases;
		__color = col;
		__duracion = duracion;
		__grosorInicial = grosor[0];
		__alphaInicial = alpha[0];
		__grosorAumento = new Array(__fases);
		__alphaAumento = new Array(__fases);
		__duracionTotal = 0;
		for(var cont:Number = 0; cont < __fases; cont += 1){
			__grosorAumento[cont] = (grosor[cont +1] - grosor[cont])/__duracion[cont];
			__alphaAumento[cont] = (alpha[cont +1] - alpha[cont])/__duracion[cont];
			__duracionTotal += __duracion[cont];
		}//for
	}//Rastros
	
	
	
	
	/*
	* defMovimiento
	* auxiliar del contructor (para no meter mas parametros),
	* este metodo define las varialbles de velocidad y
	* aceleracion
	* 
	* Paramentros:
	* ang - angulo del movimiento, 0 representa arriba, 90 representa a la derecha. debe ser en grados
	* vel - valor que tomara la variable __velocidad.
	* acel - valor que tomara la variable __aceleracion.
	*/
	public function defMovimiento(ang:Number, vel:Number, acel:Number):Void{
		var angRad:Number = ang  * (Math.PI/180);
		var seno:Number = Math.sin(angRad);
		var cose:Number = Math.cos(angRad);
		__velocidadX = seno*vel;
		__velocidadY = -cose*vel;
		__aceleracionX = seno*acel;
		__aceleracionY = -cose*acel;
	}//defMovimiento
	
	
	
	
	
	/*
	* crearRastroMisil(Number, Number, Number)
	* Crea un rastro de misil.
	* 
	* Paramentros:
	* layer - layer donde sera creado el clip que contiene los rastros.
	* pos - arreglo de posiciones, sigue las mismas reglas que el usado en el constructor.
	* 
	* Nota:
	* Lo arreglo usados como paramentos no seran copiados, por lo que
	* la modificacion externa de estos resultara en comportamientos 
	* erroneos de la clase. Se recomienda que cada ves se utilizen
	* arreglos nuevos.
	*/
	public function crearRastro(layer:Number, pos:Array):Void{
		var rastro:MovieClip = __obj.createEmptyMovieClip(NOMBRE_OBJETO + layer, layer);
		//variables de datos
		rastro.trazos = __trazos
		rastro.colorLinea = __color;
		rastro.duracion = __duracion;
		rastro.duracionTotal = __duracionTotal;
		rastro.alphaAumento = __alphaAumento;
		rastro.grosorAumento = __grosorAumento;
		rastro.velocidadX = __velocidadX;
		rastro.velocidadY = __velocidadY;
		rastro.aceleracionX = __aceleracionX;
		rastro.aceleracionY = __aceleracionY;
		//variables de control
		rastro.frameActual = 1;
		rastro.fase = 0;
		rastro.contadorDeFase = 1;
		rastro.alphaActual = __alphaInicial;
		rastro.grosorActual= __grosorInicial;
		//variables de posicion y trazo inicial
		rastro.posIni = new Array(__trazos*2);
		rastro.posFin = new Array(__trazos*2);
		rastro.lineStyle(__grosorInicial, __color, __alphaInicial);
		for(var cont:Number = 0; cont < __trazos; cont += 1){
			rastro.posIni[cont*2] = pos[cont*2];
			rastro.posIni[cont*2 +1] = pos[cont*2 +1];
			rastro.posFin[cont*2] = __pos[cont*2] + __velocidadX;
			rastro.posFin[cont*2 +1] = __pos[cont*2 +1] + __velocidadY;
			rastro.moveTo(rastro.posIni[cont*2], rastro.posIni[cont*2 +1]);
			rastro.lineTo(rastro.posFin[cont*2], rastro.posFin[cont*2 +1]);
		}//for
		//Actualizacion de clase
		__pos = pos;
		//asignacion de acciones
		rastro.onEnterFrame = function(){
			this.frameActual += 1;
			this.contadorDeFase += 1;
			if(this.frameActual <= this.duracionTotal){
				if(this.contadorDeFase > this.duracion[this.fase]){
					this.fase += 1;
					this.contadorDeFase = 1;
				}//if
				//actualizacion de variables
				this.alphaActual += this.alphaAumento[this.fase];
				this.grosorActual += this.grosorAumento[this.fase];
				//actualizacion de posiciones y trazado
				var velX:Number = this.velocidadX;
				var velY:Number = this.velocidadY;
				this.velocidadX += this.aceleracionX;
				this.velocidadY += this.aceleracionY;
				this.clear();
				this.lineStyle(this.grosorActual, this.colorLinea, this.alphaActual);
				for(var cont:Number = 0; cont < this.trazos; cont += 1){
					this.posIni[cont*2] += velX;
					this.posIni[cont*2 +1] += velY;
					this.posFin[cont*2] += this.velocidadX;
					this.posFin[cont*2 +1] += this.velocidadY;
					this.moveTo(this.posIni[cont*2], this.posIni[cont*2 +1]);
					this.lineTo(this.posFin[cont*2], this.posFin[cont*2 +1]);
				}//for
			}else{
				delete this.onEnterFrame;
				this.removeMovieClip();
			}//if
			
		}//onEnterFrame
		
		
	}//crearRastro
	
	
	
	
}//class



//Fin de archivo