Acceder a Sprite

Hola. tengo esta document class, y no entiendo por que el trace devuelve null. Gracias por la ayuda.

Código :

package {
   import flash.display.Sprite;
   
   public class Distancia extends Sprite {
      private var sSprite01:Sprite;
      private var sSprite02:Sprite;
      
      function Distancia() {
            fCrearSprite(sSprite01, 0x000000);
            fCrearSprite(sSprite02, 0xff0000);
            trace(sSprite01);//null
      }
      private function fCrearSprite(pspSprite:Sprite, pnColor:Number):void {
         pspSprite = new Sprite();
         pspSprite.graphics.beginFill(pnColor);
         pspSprite.graphics.drawRect(0, 0, 4, 4);
         pspSprite.graphics.endFill();
         pspSprite.x = Math.random() * stage.stageWidth;
         pspSprite.y = Math.random() * stage.stageHeight;
         addChild(pspSprite);
      }      
   }
}

Cambia la función a

[as]
private function fCrearSprite(name:String, pnColor:Number):void {
var pspSprite:Sprite = new Sprite();
pspSprite.graphics.beginFill(pnColor);
pspSprite.graphics.drawRect(0, 0, 4, 4);
pspSprite.graphics.endFill();
pspSprite.x = Math.random() * stage.stageWidth;
pspSprite.y = Math.random() * stage.stageHeight;
pspSprite.name = name
addChild(pspSprite);
}
[as]

Y la llamada

[as]
function Distancia() {
fCrearSprite("sSprite01", 0x000000);
trace(this.getChildByName("sSprite01");
}
[/as]

Jorge

Pero eso me complica un poco las cosas. ¿No se supone que sSprite01 deberia estar disponible despues de la llamada a la funcion?

No te complica, simplemente es hacerlo bien, en tu código el primer argumento en la función fCrearSprite no tiene ningún sentido

Jorge

"en tu código el primer argumento en la función fCrearSprite no tiene ningún sentido"
¿Por que dices eso?

Porque una variable que apunta a otra se sobreescribe, incluso te debería dar error de tipo ya que no es un sprite lo que pasas como primer argumento, a menos que sea un sprite que ya existe con lo cual CrearSprite no serviría para nada

Jorge

De hecho supongo que lo que debería ser es

y

Vamos, que la función "fCrearSprite" sólo queara un objeto sprite -devolviendo una referencia al objeto creado- Es la función "main" la que se encargaría de
1.-igualar las variable de la película principal al sprite creado
2.-añadirlos al stage

NOTA:Lo he puesto entre "quote" para que veas los cambios en negrita

Hay algo que cambia mucho de AS.2 a AS.3 y es que los nombres de instancia (o la propiedad name de un MC) pierde TODO su sentido. Personalmente creo que se mantiene por un "deje romántico". Vale, es cierto que todavía podemos usar la función getChildByName("miMC"); pero hay algo que no marcha cuando lo usamos.
Imaginemos algo simple, un .fla en AS.3 con un MC en el escenario cuyo nombre de instancia es "mimc" y cuya Clase es "Mimc". AS.3 lo que hace realmente es algo como

Código :

var mimc:Mimc=new Mimc()
addChild(mimc)

Vamos, lo que tiene es una "variable llamada mimc que hace referencia al MC". Al hacer el addChild es cierto que guarda de algún modo el string "mimc" para que podamos hacer un getChildByName, pero NO lo necesitamos. YA tenemos la variable. Es igual que, cuando en AS.2 hacíamos

Código :

//en AS.2
mimc_ref=mimc
//ya nos olvidamos de "mimc", sólo vamos a usar mimc_ref
mimc_ref._x=200  //que sería lo mismo que mimc._x=200

Evidentemente, cuando creamos los MCs o los Sprites mediante AS, no tenemos porqué darle nombre de instancia (o la propiedad name), ya que tenemos la variable.

Vale, he "engañado un poco". En AS.3 la idea es que la Clase de documento tenga definidas como variables TODOS los MCs que existan o puedan llegar a existir (en variables o en un Array) y que vayan a ser usados (cambiar su x, añadirle un evento...). Al principio incluso tendrán valor nulo, pero la idea es no controlar nunca un MC mediante su "name", sino mediante una variable que haga referencia a él (no sé si quedó claro)

Al final habia optado por una solucion muy similar a la que propones:

Código :

package {
   import flash.display.Sprite;

   public class Distancia extends Sprite {
      private var sSprite01:Sprite;
      private var sSprite02:Sprite;
      
      function Distancia() {
         sSprite01 = fCrearSprite(sSprite01, 0x000000);
         sSprite02 = fCrearSprite(sSprite02, 0xff0000);
         trace(sSprite01);//ok
      }
      private function fCrearSprite(pspSprite:Sprite, pnColor:Number):Sprite {
         pspSprite = new Sprite();
         pspSprite.graphics.beginFill(pnColor);
         pspSprite.graphics.drawRect(0, 0, 4, 4);
         pspSprite.graphics.endFill();
         pspSprite.x = Math.random() * stage.stageWidth;
         pspSprite.y = Math.random() * stage.stageHeight;
         addChild(pspSprite);
         return pspSprite;
      }      
   }
}

La cual, por cierto tambien funciona si en las llamadas utilizo la palabra clave this:

Código :

                        sSprite01 = fCrearSprite(this, 0x000000);
         sSprite02 = fCrearSprite(this, 0xff0000);

Se supone que en cada caso this hace referencia a sSprite01, sSprite02.
Pero si por ejemplo hago un trace(this) dentro de la funcion fCrearSprite me devuelve Object Distancia. ¿Como es esto?
Por cierto, tu observacion sobre la propiedad name me parece muy interesante.

En primer lugar NO uses la misma variable como argumento y como recoger el valor de la función. Realmente te valdría con un

Código :

fCrearSprite(sSprite01, 0x000000);

(y dentro de la función no devuelves ningún valor). Si usas como argumento y como valor a recoger puedes tener problemas

Eso es debido a que la variable "sSprite01" pasa como "referencia". Vamos,

Código :

//igual que cuando tenemos un MC y en una función hacemos
mover(mimc)
function mover(mimc){
   mimc._x=200
}
//o un array
miarray=new Array()
anadirUno(miarray)
function anadirUno(miarray){
   miarray.push(1)
}
//cambia el valor del Objeto MC o del objeto miarray
//pero ¡ójo! que no pasa igual con los "objetos simples" (derivados de Number, String..)
var a:int=3
anadir_Uno(a)
trace(a) //sigo siendo 3
anadir_Uno=function(a){
    a++
   trace(a)  //saldrá 4
}

Y NO "this" es el Objeto Distancia (la propia clase Distancia si quieres). Podría funcionar si escribimos

Código :

fCrearSprite(this.sSprite01, 0x000000);

pero no tiene mucho sentido usar this.

El codigo que te he puesto arriba funciona.

Código :

package {
   import flash.display.Sprite;

   public class Distancia extends Sprite {
      private var sSprite01:Sprite;
      private var sSprite02:Sprite;
      
      function Distancia() {
         sSprite01 = fCrearSprite(sSprite01, 0x000000);
         sSprite02 = fCrearSprite(sSprite02, 0xff0000);
         trace(sSprite01);//ok
      }
      private function fCrearSprite(pspSprite:Sprite, pnColor:Number):Sprite {
         pspSprite = new Sprite();
         pspSprite.graphics.beginFill(pnColor);
         pspSprite.graphics.drawRect(0, 0, 4, 4);
         pspSprite.graphics.endFill();
         pspSprite.x = Math.random() * stage.stageWidth;
         pspSprite.y = Math.random() * stage.stageHeight;
         addChild(pspSprite);
         return pspSprite;
      }      
   }

Y yo tambien pienso que el uso the this en este caso no deberia ser correcto, pero la verdad es que ya no estoy muy seguro porque el caso es que tambien funciona y no entiendo muy bien por que (creo, como tu, que this en este caso estaria haciendo referencia a la propia clase Distancia).

Respecto al codigo que pones tu como ejemplo

escribió:

A mi me da error, y ademas creo que no es correcto. Aqui te pongo un ejemplo que creo que lo demuestra:

Código :

var nNum01:Number = 3;
function fAdd1(pnNum:Number):Number {
   pnNum++;
   return pnNum;
}
nNum01 = fAdd1(nNum01);
trace(nNum01);//4

Saludos .

Funciona porque al poner el igual, la variable finalmente cogerá el valor del "return" de la función. Pero conceptualmente está mal. Vamos, estamos modificando "sSprite01", en la función por el hecho de mandarlo como argumento y, una vez acabada la función, lo estamos modificando otra vez por el hecho de igualarlo.
El que funcione cuando le mandamos como argumento "this" es algo que no entiendo muy bien. Vale, NO da error porque Distancia extiende de Sprite, pero al hacer dentro de la función

Código :

pspSprite = new Sprite();

debería "cargarse" el "Objeto Distancia" (vale, realmente el objeto "distancia" que creemos en la película principal con distancia=new Distancia())