Acceder el Stage desde cualquier clase AS3

Published by :

Al trabajar con clases AS3 en nuestros proyectos hay ocasiones en los que debemos acceder al stage principal de nuestra aplicación desde clases que no extienden a “DisplayObject”, haciendo que debamos pasar como parámetro dicho stage a las clases, esto funciona pero en realidad es un poco “sucio”.

Una solución simple es crear una clase singleton, en la cual, podemos almacenar no solo el stage principal, sino cualquier otro valor que necesitemos en varias clases. Algo así como _global de AS2, lo recuerdan?
Aquí la clase

[as] package net.tmeister.utils
{
public dynamic class Global
{
private static var global : Global

public static function getInstance() : Global
{
if ( global == null )
{
global = new Global( arguments.callee );
}
return global;
}

public function Global( caller : Function = null )
{
if ( caller != Global.getInstance )
{
throw new Error (“Global is a singleton class, use getInstance() instead”);
}
if ( Global.global != null )
{
throw new Error( “Only one Global instance should be instantiated” );
}
}
}
}
[/as]

Y su modo de uso.

[as] package
{
import flash.display.MovieClip;
import net.tmeister.utils.Global
public class Main extends MovieClip
{
private var global:Global;

public function Main()
{
global = Global.getInstance();
global.stage = stage
trace(‘global.stage’ + global.stage)
global.algunOtroValor = new MovieClip()
trace(‘global.algunOtroValor ‘ + global.algunOtroValor)
}
}
}
[/as]

Simple.

Obteniendo los hijos de un DisplayObject [AS3]

Published by :

Está en una clase simple pero muy útil, al menos para mí, que recorre todos los hijos contenidos en un DisplayObject, la clase cuenta con 2 funciones:

getAllChilds

Regresa todos los hijos contenidos en el “target”

getChildsByType

Regresa solo los hijos que sean de un tipo específico, por ejemplo solo MovieClips, o solo Botones.

DisplayObjectUtils

[as] package net.tmeister.utils
{
/**
* @author Enrique Chavez aka Tmeister
*/
import flash.display.DisplayObject;
public class DisplayObjectUtils
{
/**
*
* @param target
* @return Array
*/
public static function getAllChilds(target:*):Array
{
var listTmp:Array = [] for (var a = 0; a < target.numChildren; a++ )
{
listTmp.push (target.getChildAt(a) )
}
return listTmp
}
/**
*
* @param target
* @param type
* @return
*/
public static function getChildsByType(target:*, type:*):Array
{
var listTmp:Array = [] for (var a = 0; a < target.numChildren; a++ )
{
if (target.getChildAt(a) is type)
{
listTmp.push (target.getChildAt(a) )
}
}
return listTmp
}
}
}
[/as]

Su uso es el siguiente:

Primero creamos unos Movieclips y unos botones para tener algo que buscar.

[as] import net.tmeister.utils.DisplayObjectUtils;
import fl.controls.Button

createMovieClips()
createButtons()
getChilds()

function createButtons()
{
for(var a:Number = 0; a<2; a++)
{
var tmp:Button = new Button();
tmp.x = Math.random()*400
tmp.y = Math.random()*400
tmp.label = “buton”+a
addChild(tmp)
}
}
function createMovieClips()
{
for(var a:Number = 0; a<5; a++)
{
var tmp:MovieClip = new MovieClip();
tmp.graphics.beginFill(0x2a2a2a, .5)
tmp.graphics.drawRect(Math.random()*500, Math.random()*300, Math.random()*100, Math.random()*100);
tmp.graphics.endFill();
tmp.name = “mc”+a;
addChild(tmp)
}
}
function getChilds()
{
trace(“All Childs: ” + DisplayObjectUtils.getAllChilds(this) )
trace(“=====================================================================================”)
trace(“Movieclips: ” + DisplayObjectUtils.getChildsByType(this, MovieClip))
trace(“=====================================================================================”)
trace(“Buttons: ” + DisplayObjectUtils.getChildsByType(this, Button))

}

[/as]

Advanced round class AS3

Published by :

Esta es una clase de mucha ayuda para cuando queramos redondear números de una forma más avanzada.

AS3 cuenta con su Math.round pero esta función lo único que hace es redondear el numero al entero más cercano. Pero qué pasa si quiero redondear un número en múltiplos de 5 por ejemplo.

Para ello escribí esta sencilla clase que lo permite.

[as] package net.tmeister.utils
{
/**
*
* Advanced Round Class
* @version 0.1
* @author Enrique Chavez aka Tmeister
*
*/
public class MathUtils
{
/**
*
* Rounds a Number to the nearest multiple
* @param number Number to Round
* @param precision multiple to be rounded
* @return A number round
*
*/
public static function roundToNear(number:Number, precision:Number)
{
return Math.round( number / precision) * precision;
}
/**
*
* Rounds a Number up to the nearest multiple
* @param number Number to Round
* @param precision multiple to be rounded
* @return A number Up round
*
*/
public static function roundToUpNear(number:Number, precision:Number)
{
return Math.ceil( number / precision) * precision;
}
/**
*
* Rounds a Number down to the nearest multiple
* @param number number Number to Round
* @param precision multiple to be rounded
* @return A number down round
*
*/
public static function roundToDownNear(number:Number, precision:Number)
{
return Math.floor( number / precision) * precision;
}
}
}
[/as]

Modo de uso es tan simple como esto.

[as] import net.tmeister.utils.MathUtils;

const number:Number = 38
const precision:Number = 5

trace(MathUtils.roundToNear(number, precision)) // 40
trace(MathUtils.roundToUpNear(number, precision)) // 40
trace(MathUtils.roundToDownNear(number, precision)) // 35
[/as]

Enjoy ;)

Follow me through my day

Send requests or questions about my products, find out on what I'm working and stay tune with my updates or just say hello ;)

Array

@Tmeister

active