Namide
Scripts ActionScript 3

ActionScript 3 tips

Quelques bouts de code ActionScript 3 datants de 2007.

GetURL

// Création de la requette URL
var myRequest: URLRequest = new URLRequest("//www.google.com");

// envoi des données en ouvrant une nouvelle fenêtre
navigateToURL(myRequest, "_blank");

Send, sendAndLoad

// Création de la requette URL
var myRequest: URLRequest = new URLRequest("//www.google.com");


// CREER LE CONTENEUR DES VARIABLES

// Faire passer les infos en GET ou en POST
//myRequest.method = URLRequestMethod.POST;
myRequest.method = URLRequestMethod.GET;

// Objet URLVariables pour envoyer les données
var variables: URLVariables = new URLVariables();
variables.email = "cool";

// passage des données
myRequest.data = variables;



// ENVOYER DES DONNEES A UNE PAGE PHP

/*
// envoi des données de manière transparente
sendToURL ( myRequest );
*/


// ENVOYER ET RECUPERER DES DONNEES

// Creer l'objet URLLoader
var myLoader: URLLoader = new URLLoader();

// ecouter les évênements
myLoader.addEventListener(Event.COMPLETE, onDataReceived);
myLoader.addEventListener(IOErrorEvent.IO_ERROR, errorHandler);

// load est l'équivalent ici du sendAndLoad() sur LoadVars
myLoader.load(myRequest);


function onDataReceived(evt: Event) {

  var loader: URLLoader = URLLoader(evt.target);
  trace(loader.data);

}

function errorHandler(evt: IOErrorEvent) {
  trace("Erreur de chargement de la page");
}

Charger un objet

this.addChild(charger("marie2.jpg")); //"//farm3.static.flickr.com/2361/1940041302_43811914bf.jpg") );

function charger(url: String) {

  // création d'un conteneur pour l'objet à charger ainsi que le loader
  var chargeur_mc: Sprite = new Sprite();

  // creation du loader
  var chargeur: Loader = new Loader();
  chargeur_mc.addChild(chargeur);

  //Ajoute les gestionnaires d'événements pour contrôler la progression
  chargeur.contentLoaderInfo.addEventListener(Event.OPEN, gestionOpen);
  chargeur.contentLoaderInfo.addEventListener(ProgressEvent.PROGRESS, gestionProgress);
  chargeur.contentLoaderInfo.addEventListener(Event.COMPLETE, gestionComplete);

  //Charge l'objet externe
  chargeur.load(new URLRequest(url));

  return chargeur_mc;

  // FONCTIONS DE GESTION DES EVENEMENTS
  function gestionOpen(evt: Event): void {

    //Créer un simple préchargeur en mode texte et l'ajoute dans le sprite du loader
    var statutLoader: TextField = new TextField();
    statutLoader.text = "Chargement : 0%";

    chargeur_mc.addChild(statutLoader);

  }

  function gestionProgress(evt: ProgressEvent): void {

    // Cibler statutLoader
    var cible: DisplayObject = evt.currentTarget.loader.parent.getChildAt(1);

    //Mettre à jour le % de téléchargement pour informer l'utilisateur de la progression
    var pourcent: Number = evt.bytesLoaded / evt.bytesTotal * 100;
    TextField(cible).text = "Chargement : " + Math.round(pourcent * 100) / 100 + "%";
  }

  function gestionComplete(evt: Event): void {

    // Destruction du statutLoader
    var cible: DisplayObject = evt.currentTarget.loader.parent.getChildAt(1);
    cible.parent.removeChild(cible);
    cible = null;

    cible = evt.currentTarget.loader.parent.getChildAt(0);

  }
}

Plein écran (online)

// Il faut un bouton _fullScreen_btn
// Dans le HTML le paramètre de l'objet Flash “allowFullScreen” doit être sur “true”
_fullScreen_btn.addEventListener(MouseEvent.MOUSE_UP, handleMouseUp, false, 0, true);

function handleMouseUp(me: MouseEvent) {
  if (stage.displayState == StageDisplayState.NORMAL) {
    try {
      stage.displayState = StageDisplayState.FULL_SCREEN;
    } catch (e: SecurityError) {
      //if you don't complete STEP TWO below, you will get this SecurityError
      trace("an error has occured. please modify the html file to allow fullscreen mode")
    }
  }
}

Plein écran (CD-ROM)

stage.align = StageAlign.TOP_LEFT;
stage.displayState = StageDisplayState.FULL_SCREEN;
stage.scaleMode = StageScaleMode.NO_SCALE;

Changer projection 3D (Flash 10)

this.transform.perspectiveProjection.projectionCenter = new Point(200,200);
this.transform.perspectiveProjection.fieldOfView = 45;

Algorithme de Levenshtein

trace(levenshteinDistance("cool", "la vie c'est cool"));

function levenshteinDistance(s1: String, s2: String): int {

  var m: int = s1.length;
  var n: int = s2.length;
  var matrix: Array = new Array();
  var line: Array;
  var i: int;
  var j: int;
  for (i = 0; i <= m; i++) {
    line = new Array();
    for (j = 0; j <= n; j++) {
      if (i != 0) {
        line.push(0);
      } else {
        line.push(j);
      }
    }
    line[0] = i;
    matrix.push(line);
  }
  var cost: int;
  for (i = 1; i <= m; i++) {
    for (j = 1; j <= n; j++) {
      if (s1.charAt(i - 1) == s2.charAt(j - 1)) {
        cost = 0;
      } else {
        cost = 1;
      }
      matrix[i][j] = Math.min(matrix[i - 1][j] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j - 1] + cost);
    }
  }
  return matrix[m][n];

}

Changer couleur pixel 32bits

function changePixel(pixelValue, transparence) {

  if (pixelValue != 0x00000000) {
    //var alphaValue:uint = pixelValue >> 24 & 0xFF;
    //var red:uint = pixelValue >> 16 & 0xFF;
    //var green:uint = pixelValue >> 8 & 0xFF;
    //var blue:uint = pixelValue & 0xFF;
    var couleur: uint = pixelValue & 0xFFFFFF;
    var retour: uint = (transparence << 24) + couleur;

    return retour;

  } else {
    return pixelValue;
  }
}

Hachage Namide avec 2 int en entrée et 1 int >=0 et <=100 en sortie

function hd2(x: int, y: int): int {

  // Calculs pour "mélanger" et augmenter les tailles des nombres
  if (y < 0 && x >= 0) {
    var n1: int = y * y;
    var n2: int = x * x;
  } else if (y >= 0 && x >= 0) {
    n1 = y * y;
    n2 = x;
  } else if (y >= 0 && x < 0) {
    n1 = x;
    n2 = y * y;
  } else {
    n1 = x * x;
    n2 = y * y;
  }

  if (n2 < 0) n2 *= -1;

  // Calcul de la longueur de n2 puis collage de n1 et n2
  var longN2: int = 1 + Math.log(n2) * 0.43429448190325187; //1 + Math.log(n2) / Math.log(10);
  var input: int = n1 * Math.pow(10, longN2) + n2;

  // METHODE DU CARRE MEDIAN
  var inputUint: uint = (input * input) % 0xFFFFFFFF;

  // Calcul de la longueur de input
  const long: int = 1 + Math.log(inputUint) * 0.36067376022224085; //=1 + Math.log(inputUint) / Math.log(16);//=2^((A8-1)*4)
  // Récupération des 2 nombres hexadécimaux du centre de inputUint
  var milieu: uint = inputUint >> int((long - 2) << 1) & 0xFF;

  // Conversion d'un maximum en 256 en un maximum en 100 : int(100*milieu/256)
  return int(0.39453125 * milieu);
}

Calcul FPS

addEventListener(Event.ENTER_FRAME, calcFPS);
var timer: Object = {
  "t": getTimer(),
  "img": 0,
  "ini": false
};

function calcFPS(evt) {
  if (timer.ini != true) {
    var t_fps: TextField = new TextField();
    t_fps.width = 30;
    t_fps.height = 20;
    t_fps.text = "test";
    t_fps.background = true;
    addChild(t_fps);
    timer.ini = true;
    timer.cible = t_fps;
  }
  if (timer.t + 1000 < getTimer()) {
    TextField(timer.cible).text = String(timer.img);
    timer.img = 0;
    timer.t = getTimer();
  } else {
    timer.img++;
  }
}

Ondulations Bitmap

var fondOndu: Object = new Object();
fondOndu.t = getTimer();
fondOndu.marge = 2000;
fondOndu.largeurIni = 960 + fondOndu.marge;
fondOndu.hauteurIni = 600 + fondOndu.marge;

stage.addEventListener(Event.RESIZE, resizeHandler);

function resizeHandler(event: Event): void {

  fondOndu.larg = stage.stageWidth + fondOndu.marge;
  fondOndu.haut = stage.stageHeight + fondOndu.marge;

  // FOND

  fondOndu.bm.x = -(stage.stageWidth - 960) / 2;
  fondOndu.bm.y = -(stage.stageHeight - 600) / 2;

  rafraichir(new Event("faux"));
  fondOndu.bm.width = fondOndu.larg;
  fondOndu.bm.height = fondOndu.haut;

}

function algo_dd(x, y, t) {

  var taille: uint = 10 / fondOndu.qualitee

  var varX: Number = Math.PI / taille;
  var varY: Number = Math.E / taille;
  var longOnde: Number = 0.01;

  var onde = Number(((Math.cos(x * longOnde / taille - t * Math.PI / 2) * Math.cos(x * varX * longOnde - t) * Math.sin(y * longOnde / taille + t / Math.E) * Math.sin(y * varY * longOnde + t) + 1) / 2));

  var R: uint = 0xFF;
  var V: uint = 0xFF;
  var B: uint = (onde) * 0xFF;

  return R * 0x10000 + V * 0x100 + B;
}

function rafraichir(e) {

  var dt: int = 1000 / (getTimer() - fondOndu.t);
  fondOndu.t = getTimer();

  var largIni: uint = int(fondOndu.largeurIni * fondOndu.qualitee);
  var hautIni: uint = int(fondOndu.hauteurIni * fondOndu.qualitee);

  var t2: Number = fondOndu.t / 5000

  for (var i: uint = 0; i < largIni; i++) {
    for (var j: uint = 0; j < hautIni; j++) {
      fondOndu.bmd.setPixel(
        i,
        j,
        algo_dd(i * fondOndu.larg / (fondOndu.qualitee * largIni),
          j * fondOndu.haut / (fondOndu.qualitee * hautIni),
          t2)
      );
    }
  }

}

fondOndu.larg = stage.stageWidth + fondOndu.marge;
fondOndu.haut = stage.stageHeight + fondOndu.marge;
fondOndu.qualitee = 1 / 64;
fondOndu.bmd = new BitmapData(int(fondOndu.largeurIni * fondOndu.qualitee), int(fondOndu.hauteurIni * fondOndu.qualitee), false, 0xFFCC00);
fondOndu.bm = new Bitmap(fondOndu.bmd, "auto", true);
addChildAt(fondOndu.bm, 0);

this.addEventListener(Event.ENTER_FRAME, rafraichir);
resizeHandler(new Event("ini"));

Redimentionner un objet

// cible = objet à redimentionner (sprite, MovieClip etc)
// Premier point = largeur et hauteur max
// Deuxième point = position x et y
redimentionner(cible, new Point(50, 200), new Point(5, 10))

function redimentionner(cible: DisplayObject, tailleMax: Point, pos: Point) {

  // Récupère les tailles de l'objet et on génère un rapport de proportions
  var larg: Number = cible.width
  var haut: Number = cible.height
  var rapport1: Number = larg / haut;

  // Récupère les tailles maximales et on génère un rapport de proportions
  var largMax: Number = tailleMax.x
  var hautMax: Number = tailleMax.y
  var rapport2: Number = largMax / hautMax;

  // Si la largeur est plus grande proportionnellement que le maximum autorisé
  if (rapport1 > rapport2) {

    // On ajuste l'image à la largeur max
    cible.width = largMax;
    cible.scaleY = cible.scaleX;

    var hautManq: Number = hautMax - cible.height

    cible.x = pos.x;
    cible.y = pos.y + Math.round(hautManq / 2);

    // Si la largeur est plus petite
  } else if (rapport1 < rapport2) {

    // On ajuste l'image à la hauteur max
    cible.height = hautMax;
    cible.scaleX = cible.scaleY;

    var largManq: Number = largMax - cible.width;

    cible.x = pos.x + Math.round(largManq / 2);
    cible.y = pos.y;

    // Si le rapport de proportionnalité est le même
  } else {

    cible.height = hautMax;
    cible.width = largMax;

    cible.x = pos.x;
    cible.y = pos.y;

  }

}

Tri rapide

var tableau: Array = new Array({
  a: 1,
  rang: 48
}, {
  a: 2,
  rang: 452
}, {
  a: 3,
  rang: 786
}, {
  a: 4,
  rang: 021
}, {
  a: 5,
  rang: 2452
})

triRapide(tableau, 0, tableau.length - 1);

for (var i: uint; i < tableau.length; i++) {
  trace(tableau[i].a + " " + tableau[i].rang)
}

function triRapide_partition(tableau, deb, fin) {

  var compt: uint = deb;
  var pivot: uint = tableau[deb].rang;

  for (var i: uint = deb + 1; i <= fin; i++) {

    if (tableau[i].rang < pivot) {
      compt++;
      triRapide_echanger(tableau, compt, i);
    }

  }

  triRapide_echanger(tableau, deb, compt);

  return (compt);

}

function triRapide(tableau, deb, fin) {

  if (deb < fin) {

    var positionPivot: uint = triRapide_partition(tableau, deb, fin);

    triRapide(tableau, deb, positionPivot - 1);
    triRapide(tableau, positionPivot + 1, fin);

  }

}

function triRapide_echanger(tableau, val1, val2) {
  var a: Object = tableau[val1];
  var b: Object = tableau[val2];

  tableau[val1] = b;
  tableau[val2] = a;
}

Tracer des courbes passant par des points

import flash.display.Sprite;

init(3);

function init(nbrePoints): void {
  var points: Array = new Array();
  for (var i: int = 0; i < nbrePoints + 1; i++) {
    points[i] = new Object();
    points[i].x = Math.random() * stage.stageWidth; //pts_liste[i].x;
    points[i].y = Math.random() * stage.stageHeight; //pts_liste[i].y;
  }
  graphics.lineStyle(1);

  graphics.moveTo(points[0].x, points[0].y);
  doDrawCircle(points[0].x, points[0].y, 0xFF0000);

  for (i = 1; i < nbrePoints - 1; i++) {
    var xc: Number = (points[i].x + points[i + 1].x) / 2
    var yc: Number = (points[i].y + points[i + 1].y) / 2
    graphics.curveTo(points[i].x, points[i].y, xc, yc);

    doDrawCircle(xc, yc, 0xFF0000);
    doDrawCircle(points[i].x, points[i].y, 0x0000FF);
  }

  doDrawCircle(points[i + 1].x, points[i + 1].y, 0xFF0000);
  graphics.curveTo(points[i].x, points[i].y, points[i + 1].x, points[i + 1].y);
}

function doDrawCircle(x, y, couleur): void {
  var child: Shape = new Shape();
  //child.graphics.beginFill(couleur);
  child.graphics.lineStyle(1, couleur);
  child.graphics.drawCircle(x, y, 5);
  child.graphics.endFill();
  addChild(child);
}

Pack

Moteur 3D

/*
Pour ce script il faut :
- La bibliothèque de tween caurina (sinon supprimer les lignes 9 et 64)
- Un objet lié (MovieClip), 250x250px avec comme nom de classe : "image"
(sinon remplacer la ligne 33)
*/
import caurina.transitions.Tweener;

// CREATION DE L'ESPACE 3D
var espace3D: Object = new Object();
espace3D.cible = new Sprite();
addChild(espace3D.cible);
espace3D.centreX3D =
  espace3D.centreY3D = 0;
espace3D.centreZ3D = 1000;
espace3D.centreX2D = stage.stageWidth / 2;
espace3D.centreY2D = stage.stageHeight / 2;
espace3D.listObjets = new Array();
espace3D.focale = 200;
espace3D.rotAxeX = 0;
espace3D.rotAxeY = 0;
espace3D.rotAxeZ = 0;

for (var i: int = 0; i < 10; i++) iniObjet();
addEventListener(Event.ENTER_FRAME, aff3D);

// CREATION DES OBJETS DANS L'ESPACE 3D
function iniObjet() {
  var rayonSphere: Number = 400;

  var photo: image = new image();
  var phy: Number = Math.random() * 2 * Math.PI;
  var teta: Number = Math.random() * 2 * Math.PI; //pos Z ?

  var obj: Object = new Object();

  obj.phy_ini = phy;
  obj.teta_ini = teta;

  obj.posX_ini = rayonSphere * Math.sin(teta) * Math.cos(phy);
  obj.posY_ini = rayonSphere * Math.sin(teta) * Math.sin(phy);
  obj.posZ_ini = rayonSphere * Math.cos(teta);

  obj.cible = photo;

  var axeRot: Object = determinerAxeRotationObj(obj);
  obj.butRotX = axeRot.X;
  obj.butRotY = axeRot.Y;
  obj.butRotZ = axeRot.Z;

  obj.cible.donnee = obj;
  obj.cible.addEventListener(MouseEvent.CLICK, cliquePhoto);
  obj.cible.buttonMode = true;

  espace3D.listObjets.push(obj);

}

// ACTION QUAND ON CLIQUE SUR UN OBJET
function cliquePhoto(evt) {
  var cible: Object = evt.currentTarget.donnee;
  Tweener.addTween(espace3D, {
    rotAxeX: cible.butRotX,
    rotAxeY: cible.butRotY,
    rotAxeZ: cible.butRotZ,
    time: 5,
    transition: "easeOutElastic"
  });
}

function aff3D(evt) {

  while (espace3D.cible.numChildren > 0) espace3D.cible.removeChildAt(0);
  var numObj_temp: int = espace3D.listObjets.length;
  var zBuffer: Array = new Array();

  // Lancement des calculs de rendu
  for (var i: int = 0; i < numObj_temp; i++) {
    var obj: Object = espace3D.listObjets[i];

    obj.posX3D = obj.posX_ini + espace3D.centreX3D;
    obj.posY3D = obj.posY_ini + espace3D.centreY3D;
    obj.posZ3D = obj.posZ_ini + espace3D.centreZ3D;

    var pos: Object = {
      "X": obj.posX3D,
      "Y": obj.posY3D,
      "Z": obj.posZ3D
    }

    pos = rotationObj(pos, espace3D.rotAxeX, "X", {
      "X": espace3D.centreX3D,
      "Y": espace3D.centreY3D,
      "Z": espace3D.centreZ3D
    });
    pos = rotationObj(pos, espace3D.rotAxeY, "Y", {
      "X": espace3D.centreX3D,
      "Y": espace3D.centreY3D,
      "Z": espace3D.centreZ3D
    });
    pos = rotationObj(pos, espace3D.rotAxeZ, "Z", {
      "X": espace3D.centreX3D,
      "Y": espace3D.centreY3D,
      "Z": espace3D.centreZ3D
    });

    obj.posX3D = pos.X;
    obj.posY3D = pos.Y;
    obj.posZ3D = pos.Z;

    var scale: Number = espace3D.focale / obj.posZ3D;

    obj.posX2D = (obj.posX3D) * scale + espace3D.centreX2D;
    obj.posY2D = (obj.posY3D) * scale + espace3D.centreY2D;
    obj.scale = scale;

    obj.cible.x = obj.posX2D;
    obj.cible.y = obj.posY2D;
    obj.cible.scaleX = obj.cible.scaleY = obj.scale;

    zBuffer.push({
      cible: obj.cible,
      rang: int(scale * 100000)
    });
  }

  // Lancement du tri rapide et mise en place des objets dans l'espace 3D
  triRapide(zBuffer, 0, zBuffer.length - 1);
  for (i = 0; i < zBuffer.length; i++) {
    if (zBuffer[i].rang > 0)
      espace3D.cible.addChild(zBuffer[i].cible);
  }

  // TRI RAPIDE => pour le z-buffer
  function triRapide(tableau, deb, fin) {
    if (deb < fin) {
      var positionPivot: uint = triRapide_partition(tableau, deb, fin);
      triRapide(tableau, deb, positionPivot - 1);
      triRapide(tableau, positionPivot + 1, fin);
    }

    function triRapide_partition(tableau, deb, fin) {
      var compt: uint = deb;
      var pivot: uint = tableau[deb].rang;
      for (var i: uint = deb + 1; i <= fin; i++) {
        if (tableau[i].rang < pivot) {
          compt++;
          triRapide_echanger(tableau, compt, i);
        }
      }
      triRapide_echanger(tableau, deb, compt);
      return (compt);

      function triRapide_echanger(tableau, val1, val2) {
        var a: Object = tableau[val1];
        var b: Object = tableau[val2];
        tableau[val1] = b;
        tableau[val2] = a;
      }
    }
  }
}

// TROUVER LES DONNEES DE ROTATION POUR FAIRE PASSER L'OBJET DEVANT
function determinerAxeRotationObj(obj) {

  var pos: Object = new Object();
  pos.X = obj.posX_ini;
  pos.Y = obj.posY_ini;
  pos.Z = obj.posZ_ini;

  var axePolaireX: Number = -Math.PI / 2 - determinerAnglePolaire("X");
  pos = rotationObj(pos, axePolaireX, "X", {
    "X": 0,
    "Y": 0,
    "Z": 0
  })
  var axePolaireY: Number = -Math.PI / 2 - determinerAnglePolaire("Y");
  var axePolaireZ: Number = 0;

  return {
    "X": axePolaireX,
    "Y": axePolaireY,
    "Z": axePolaireZ
  };

  function determinerAnglePolaire(axeRotation) {
    if (axeRotation == "Y") {
      var axe1: String = "X";
      var axe2: String = "Z";
    } else if (axeRotation == "X") {
      axe1 = "Y";
      axe2 = "Z";
    } else if (axeRotation == "Z") {
      axe1 = "X";
      axe2 = "Y";
    }

    var axePolaire: Number = Math.sqrt(pos[axe1] * pos[axe1] + pos[axe2] * pos[axe2]);

    if (pos[axe1] > 0) var anglePolaire: Number = Math.atan(pos[axe2] / pos[axe1]);
    if (pos[axe1] < 0 && pos[axe2] >= 0) anglePolaire = Math.atan(pos[axe2] / pos[axe1]) + Math.PI;
    if (pos[axe1] < 0 && pos[axe2] < 0) anglePolaire = Math.atan(pos[axe2] / pos[axe1]) - Math.PI;
    if (pos[axe1] == 0 && pos[axe2] > 0) anglePolaire = Math.PI / 2;
    if (pos[axe1] == 0 && pos[axe2] < 0) anglePolaire = -Math.PI / 2;

    return anglePolaire;
  }

}

// EFFECTUER UNE ROTATION
function rotationObj(obj, angle, axeRotation, centreRotation) {

  var reponse: Object = new Object();

  var pos: Object = new Object();
  pos.X = obj.X - centreRotation.X;
  pos.Y = obj.Y - centreRotation.Y;
  pos.Z = obj.Z - centreRotation.Z;

  if (axeRotation == "Y") {
    var axe1: String = "X";
    var axe2: String = "Z";
    reponse.Y = pos.Y + centreRotation.Y;
  } else if (axeRotation == "X") {
    axe1 = "Y";
    axe2 = "Z";
    reponse.X = pos.X + centreRotation.X;
  } else if (axeRotation == "Z") {
    axe1 = "X";
    axe2 = "Y";
    reponse.Z = pos.Z + centreRotation.Z;
  }

  var axePolaire: Number = Math.sqrt(pos[axe1] * pos[axe1] + pos[axe2] * pos[axe2]);

  if (pos[axe1] > 0) var anglePolaire: Number = Math.atan(pos[axe2] / pos[axe1]);
  if (pos[axe1] < 0 && pos[axe2] >= 0) anglePolaire = Math.atan(pos[axe2] / pos[axe1]) + Math.PI;
  if (pos[axe1] < 0 && pos[axe2] < 0) anglePolaire = Math.atan(pos[axe2] / pos[axe1]) - Math.PI;
  if (pos[axe1] == 0 && pos[axe2] > 0) anglePolaire = Math.PI / 2;
  if (pos[axe1] == 0 && pos[axe2] < 0) anglePolaire = -Math.PI / 2;

  anglePolaire += angle;

  reponse[axe1] = axePolaire * Math.cos(anglePolaire);
  reponse[axe2] = axePolaire * Math.sin(anglePolaire);

  reponse[axe1] += centreRotation[axe1];
  reponse[axe2] += centreRotation[axe2];

  return reponse;

}

Compilation conditionelle (merci Vulcain)

//-define=CONFIG::release,false -define=CONFIG::debug,true

package fr.estei.puremvc.exo2.facade
{
  import fr.kapit.puremvc.as3.patterns.facade.DebugFacade;
  import org.puremvc.as3.patterns.facade.Facade;

  CONFIG::release 
  public class SwitchFacade extends Facade
  {
    public function SwitchFacade()
    {
      super();
    }
  }

  CONFIG::debug 
  public class SwitchFacade extends DebugFacade
  {
    public function SwitchFacade()
    {
      super();
    }
  }
}