Carregando SWF externo

[PERCY.FERNANDES 0]

Boa noite a todos.

 

Estou tentando carregar um SWF externo com código na timeline em um mc carregador dentro de outro mc posto no palco.

O problema é que o SWF externo se originou de um FLA que recebe uma classe de um arquivo.AS externo a ele. Usando os métodos Loader e UrlRequest ao rodar o mc carregador surge uma mensagem de referência de objeto nula. Pelo pouco que entendo, o objeto criado pela classe externa ao FLA que origina o SWF externo não é reconhecido em tempo de execução no SWF carregador. Há solução para isso?

[Elektra 102]

Por favor, poste o code que está usando.

 

Talvez o 'caminho' para alcançar o local de carregamento precise algum ajuste.

 

 

Abraços

[PERCY.FERNANDES 0]

Esta é a classe (Sistema.as) definida externamente no PUBLISH do Sistema.fla que irá gerar Sistema.swf a ser carregado. Sistema.fla na verdade está vazio, só recebe esta classe para a publicação do swf a ser carregado.

 

package 
{
   import flash.display.*; 
   import flash.events.*;
   import flash.geom.*;

   public class Sistema extends Sprite
   {
       public var Xref:Number=50; 
	public var Yref:Number=50;  
	public var H:Number;
       public var L:Number;
	public var v:Number;
	public var v0:Number;
	public var v1:Number;
       public var veloIni:Number = 5;
	public var gravidade:Number = 0;
	public var moleculas:Array;
	public var numMoleculas:Number = 100;
     	public var coefRestMol:Number = 1.0;
       public var coefRestReserv:Number = 1;
       public var raio:Number = 3;
	public var anguloIni:Number;
       public var k:int;
	public var cor:ColorTransform = new ColorTransform();
	public var caixa:Sprite = new Sprite();
	public var rastro:Sprite = new Sprite();

       public function Sistema()
       {
           //Calcula as medidas do reservatório.
		L = stage.stageWidth - 2 * Xref;
           H = stage.stageHeight - 2 * Yref;

		//Desenha o reservatório
		caixa.graphics.beginFill(0x00AA77);
           caixa.graphics.drawRect(Xref, Yref, L, H);
           caixa.graphics.endFill();
           addChild(caixa);

		//Dispõe todas as moléculas dentro do reservatório
		moleculas = new Array();
		for (k=0 ; k < numMoleculas ; k++)
           {
              	if(k==0)
				{
					molecula = new Molecula(10 * raio, 0x00ff00);
					anguloIni = Math.random() * 360;
               		molecula.x = Math.random() * (L - 2 * raio) + Xref + raio;
               		molecula.y = Math.random() * (H - 2 * raio) + Yref + raio;
					molecula.vx = Math.random() * veloIni * Math.sin(anguloIni);
               		molecula.vy = Math.random() * veloIni * Math.cos(anguloIni);
               		v = Math.sqrt(molecula.vx * molecula.vx + molecula.vy * molecula.vy);
               		molecula.name = "molecula" + k;
               		molecula.massa = 10;
               		addChild(molecula);
					moleculas.push(molecula);
					//Inicia o rastro
					rastro.graphics.lineStyle(1,0x0000ff,0.5);
					rastro.graphics.moveTo(moleculas[0].x,moleculas[0].y);
					addChild(rastro);
				}
			molecula = new Molecula(raio, 0xff0000);
			anguloIni = Math.random() * 360;
               molecula.x = Math.random() * (L - 2 * raio) + Xref + raio;
               molecula.y = Math.random() * (H - 2 * raio) + Yref + raio;
               molecula.vx = Math.random() * veloIni * Math.sin(anguloIni);
               molecula.vy = Math.random() * veloIni * Math.cos(anguloIni);
               v = Math.sqrt(molecula.vx * molecula.vx + molecula.vy * molecula.vy);
               cor.redMultiplier = v / veloIni;
               cor.blueMultiplier = veloIni - v / veloIni;
               molecula.transform.colorTransform = cor;
               molecula.name = "molecula" + k;
               molecula.massa = 10;
               addChild(molecula);
			moleculas.push(molecula);
           }
		addEventListener(Event.ENTER_FRAME, onFrame);
		return;
       }

       public function onFrame(param1:Event) : void
       {
           var moleculaA:Molecula; 
           var moleculaB:Molecula;
		var moleculaTemp:Molecula;
           var corA:ColorTransform;
           var corB:ColorTransform;
	   	var i:int;
		var j:int;
	   	var dx:Number;
           var dy:Number;
           var d:Number;
           var dmin:Number;
           var tetaX:Number;
           var vAn:Number;
           var vBn:Number;
           var vAt:Number;
           var vBt:Number;
           var temp:Number;

		//Análise das colisões

           for (i=0 ; i < numMoleculas + 1 ; i++)
           {
               moleculaA = moleculas[i];
               for (j=i+1 ; j < numMoleculas + 1 ; j++)
               {
				moleculaB = moleculas[j];
				dx = moleculaB.x - moleculaA.x;
				dy = moleculaB.y - moleculaA.y;
				d = Math.sqrt(dx * dx + dy * dy);
				dmin = moleculaA.raio + moleculaB.raio;

				corA = new ColorTransform();
				corB = new ColorTransform();

			   	//Verifica se há colisão e aplica o princípio da conservação do momentum
				if (d < dmin)
                	{
					tetaX = Math.atan2(dy,dx);  //Ângulo de inclinação da reta tangente ao ponto de colisão das duas moléculas
					moleculaB.x = moleculaA.x + Math.cos(tetaX) * dmin; // A molécula B é posicionada tangencialmente à molécula A
					moleculaB.y = moleculaA.y + Math.sin(tetaX) * dmin; // no caso da distância instantânea entre elas ser menor que a soma de seus raios.

					vAn = moleculaA.vx * Math.cos(tetaX) + moleculaA.vy * Math.sin(tetaX);
					vBn = moleculaB.vx * Math.cos(tetaX) + moleculaB.vy * Math.sin(tetaX);
					vAt = moleculaA.vx * Math.sin(tetaX) - moleculaA.vy * Math.cos(tetaX);
					vBt = moleculaB.vx * Math.sin(tetaX) - moleculaB.vy * Math.cos(tetaX);
					temp = vAn;
					vAn = (moleculaA.massa * vAn + moleculaB.massa * vBn - coefRestMol * moleculaB.massa * vAn + coefRestMol * moleculaB.massa * vBn) / (moleculaA.massa + moleculaB.massa);
					vBn = coefRestMol * (temp - vBn) + vAn;
					moleculaA.vx = vAn * Math.cos(tetaX) + vAt * Math.sin(tetaX);
					moleculaA.vy = vAn * Math.sin(tetaX) - vAt * Math.cos(tetaX);
					moleculaB.vx = vBn * Math.cos(tetaX) + vBt * Math.sin(tetaX);
					moleculaB.vy = vBn * Math.sin(tetaX) - vBt * Math.cos(tetaX);
				}

				//Atualiza a cor da partícula em função de sua velocidade
				vA = Math.sqrt(moleculaA.vx * moleculaA.vx + moleculaA.vy * moleculaA.vy);
				vB = Math.sqrt(moleculaB.vx * moleculaB.vx + moleculaB.vy * moleculaB.vy);
				corA.redMultiplier = vA / veloIni;
				corB.redMultiplier = vB / veloIni;
				//corA.blueMultiplier = veloIni - vA / veloIni;
				//corB.blueMultiplier = veloIni - vB / veloIni;
				moleculaA.transform.colorTransform = corA;
				moleculaB.transform.colorTransform = corB;
			}
		}

           for (i=0 ; i < numMoleculas + 1; i++)
           {
              moleculaTemp = moleculas[i];
		   move(moleculaTemp);
           }

		//Rastro do corpo de prova
		rastro.graphics.lineTo(moleculas[0].x,moleculas[0].y);

		return;
       }


	private function move(param1:Molecula) : void
       {
           param1.vy = param1.vy + gravidade;
           param1.x = param1.x + param1.vx;
           param1.y = param1.y + param1.vy;
           param1.cor = param1.vx * param1.vy * 0xff0000;

		if (param1.x + param1.raio > Xref + L) //Verifica reflexão na parede direita
           {
               param1.x = Xref + L - param1.width / 2;
               param1.vx = param1.vx * (-coefRestReserv);
           }
           else if (param1.x - param1.raio < Xref) //Verifica reflexão na parede esquerda
           {
               param1.x = Xref + param1.raio;
               param1.vx = param1.vx * (-coefRestReserv);
           }
           if (param1.y < Yref + param1.raio) //Verifica reflexão na parede superior
           {
               param1.y = Yref + param1.raio;
               param1.vy = param1.vy * (-coefRestReserv);
           }
           else if (param1.y > Yref + H - param1.raio) //Verifica reflexão na parede inferior
           {
               param1.y = Yref + H - param1.raio;
               param1.vy = param1.vy * (-coefRestReserv);
           }
           return;
       }

   }

} 

 

Esta é a classe (Molecula.as) usada pela classe Sistema.as.

 

package 
{
   import flash.display.*;

   public class Molecula extends Sprite
   {
       public var vx:Number = 0;
       public var vy:Number = 0;
       public var raio:Number;
       public var cor:uint;
       public var massa:Number = 0;

       public function Molecula(param1, param2)
       {
           this.raio = param1;
           this.cor = param2;
           criaMolecula();
           return;
       }

       public function criaMolecula() : void
       {
           graphics.beginFill(cor);
           graphics.drawCircle(0, 0, raio);
           graphics.endFill();
           return;
       }

   }
}

 

E esse é o código que usei para o carregamento no teste.fla que irá carregar Sistema.swf.

 

var loaderA:Loader = new Loader(); 
loaderA.load(new URLRequest("Sistema.swf"));
addChild(loaderA); 

 

Não se ofenda com o excesso no detalhamento da explicação. Não estou subestimando ninguém. Só não quero deixar dúvidas. Muito agradecido pela atenção.

[Andre Cocuroci 0]

Percy, neste link tem a resolução deste problema:

http://forum.imasters.com.br/topic/425435-eliminar-execucao-de-funcoes-de-swf-externo/

 

O que está acontecendo é que quando o Sistema.swf tenta acessar o stage ele ainda não está disponivel.

[PERCY.FERNANDES 0]

Bem André.

 

O Sistema.swf é criado à partir de um Sistema.fla que não possui programação. Ele simplesmente recebe a classe Sistema.as.

Assim não sei onde inserir o que você sugeriu.

[Andre Cocuroci 0]

Então, retire tudo do construtor da classe e coloque este código:

 

 public function Sistema() {
 addEventListener(Event.ADDED_TO_STAGE, init);
}

 

Depois crie um metodo com o que você retirou do construtor, ficando deste jeito:

 

public function init(e:Event)        {
 //coloque tudo que estava no construtor e depois remova o ADDED_TO_STAGE
 removeEventListener(Event.ADDED_TO_STAGE, init);
}