Aujourd’hui voici un petit tutoriel sur la création d’une enveloppe d’une forme convexe.

notre forme sera un polygone constitué d’une nombre indéfinis de points.Le code présenté est inspiré de l’algorithme du parcours de Graham

on crée un tableau enveloppe qui stockera les points à relier. Le tableau d’objet points à au départ 2 propriétés : X et Y

var enveloppe:Array = [];

//Recherche du point le plus bas
var bas:Object = points.sortOn("y",Array.NUMERIC)[points.length-1];
points.pop();

Puis on affecte une propriété angle définies par rapport au point le plus bas

//Tri du reste du nuage en fonction des angles par rapport au point le plus bas
sens_trigo( bas,points ) ;
points.sortOn("angle",Array.NUMERIC);
enveloppe.push(bas);
points.push(bas);

enfin , nous pouvons créer l’enveloppe :

while(points.length > 0)
{
	//On retire le premier point du nuage et on le place dans l'enveloppe
	enveloppe.push(points.shift() ) ;
}

var spr:Shape = new Shape();
spr.graphics.lineStyle(group.@weight,group.@color);
spr.graphics.beginFill(group.@color);

for (var incS:int = 0; incS < enveloppe.length ; incS++)
{
	if(incS == 0)
	{
		spr.graphics.moveTo(enveloppe[incS].x,enveloppe[incS].y+20);
	}
	else
	{
		var deltaX:Number = enveloppe[incS].x-enveloppe[incS-1].x;
		var deltaY:Number = enveloppe[incS].y-enveloppe[incS-1].y;
		if(deltaX > 0)
			spr.graphics.curveTo(enveloppe[incS].x-deltaX/2,enveloppe[incS].y+Math.abs(deltaY),enveloppe[incS].x+20,enveloppe[incS].y);
		else
			spr.graphics.curveTo(enveloppe[incS].x-deltaX/2,enveloppe[incS].y-Math.abs(deltaY),enveloppe[incS].x-20,enveloppe[incS].y);
	}
}
spr.graphics.endFill();

Méthode sens_trigo :

private function sens_trigo(bas:Object,points:Array):void
{
     for each(var p:Object in points)
     {
	var angleRadian:Number = Math.atan2(bas.x - p.x, bas.y - p.y);
	var angleDegree:Number = angleRadian * (180 / Math.PI);
	p.angle = angleDegree;
      }
}

Pour rappel le pseudo code du parcours de Graham est celui ci :

Trouver le pivot P;
Trier les points par angle (les points d'angle égal seront triés par rapport à leur abscisse);

# Points[1] est le pivot, Points[longueur] aussi (fin du circuit)
Pile.empiler(Points[1]);
Pile.empiler(Points[2]);
POUR i = 3 A Points.longueur
        TANT QUE (Pile.hauteur >= 2) ET (Produit_vectoriel(Pile.second, Pile.haut, Points[i]) <= 0)
                Pile.dépiler;
        FIN TANT QUE
        Pile.empiler(Points[i]);
FIN POUR

FONCTION Produit_vectoriel(p1, p2, p3)
        RENVOYER(p2.x - p1.x)*(p3.y - p1.y) - (p3.x - p1.x)*(p2.y - p1.y);
FIN FONCTION

Voici le 7 eme et dernier article sur les design pattern en Action Script 3 : le decorateur.

Un décorateur permet d’attacher dynamiquement de nouvelles responsabilités à un objet. Les décorateurs offrent une alternative assez souple à l’héritage pour composer de nouvelles fonctionnalités.

chaque couche implémente l’interface et delege a la couche inférieure. il invente de nouvelles fonctionnalités mais pas de nouvelles méthodes publiques.

Cette classe est un decorator :

package userInterface.contenu
{
	import flash.display.Sprite;
	import flash.events.IEventDispatcher;

	import userInterface.IInitDestroy;

	public interface IContenu extends IEventDispatcher , IInitDestroy
	{
		// 2 methodes implementes par AUserIterface
		function get content():Sprite;
		function active(value:Boolean):void;

		// 4 methodes implementes par BContenu
		function open():void;
		function close():void;
		function set animatorOpen(value:ContentAnimator):void;
		function set animatorClose(value:ContentAnimator):void;
	}
}

Cette classe utilise le decorateur pour utiliser les méthodes du decorateur , sans rajouter de nouvelle méthodes a celle ci :

package userInterface.contenu
{
	import flash.display.Sprite;
	import flash.events.Event;

	/* classe abstraite implementant icontenu
	les classes heritant de cette classe ont les memes methodes */
	public class AContenuDecorator implements IContenu
	{
		protected var _contenuAdecorer:IContenu;

		public function AContenuDecorator(contenuAdecorer:IContenu)
		{
			_contenuAdecorer = contenuAdecorer;
		}

		public function init():void
		{
			_contenuAdecorer.init();
		}

		public function destroy():void
		{
			_contenuAdecorer.destroy();

		}

		public function active(value:Boolean):void
		{
			_contenuAdecorer.active(value);
		}

		public function open():void
		{
			_contenuAdecorer.open();
		}

		public function close():void
		{
			_contenuAdecorer.close();
		}
	}
}

Le patron de conception Command est un patron de type comportemental qui encapsule la notion d’invocation. Il permet de séparer complètement le code initiateur de l’action, du code de l’action elle-même. Le design pattern Command est souvent utilisé dans les IHM où, par exemple, un élément de menu peut actionner différentes Commandes de façons à ce que l’objet de cet élément n’ait pas besoin de connaître les détails de l’action effectuée par la Commande.

L’utilisation de ce patron de conception est recommandé lorsqu’il y a trop de commandes similaires et que le code devient difficile à maintenir.

Un objet Commande sert à communiquer une action à effectuer, ainsi que les arguments requis. L’objet est envoyé à une seule méthode dans une classe, qui traite les Commandes du type requis. L’objet est libre d’implémenter le traitement de la Commande par un switch, ou un appel à d’autres méthodes. Cela permet d’apporter des modifications aux Commandes définies simplement dans la définition de la Commande, et non dans chaque classe qui utilise la Commande.

Exmple d’utilisation du patron de conception Command en Action Script 3 :

// création d'un objet command

var clickMenu:clickMenuCommand = new clickMenuCommand(*);
// eexecution de cet objet

MainController.instance.commandManager.exec(clickMenu);

Le patron de conception stratégie couramment utilisé pour des situations où il est nécessaire de permuter dynamiquement les algorithmes utilisés dans une application. Il est ainsi est prévu pour fournir le moyen de définir une famille d’algorithmes, encapsuler chacun d’eux en tant qu’objet, et les rendre interchangeables.

Une classe utilisant ce pattern reste fermée à la modification mais ouverte a l’extension et ne fais ne fais que moduler un comportement deja existant.

Exemple d’implémentation en actionScript 3 :

public function set animatorOpen(value:ContentAnimator):void
{
	_animatorOpen = value;
	_animatorOpen.contentToAnim = _content;
}

public function set animatorClose(value:ContentAnimator):void
{
	_animatorClose = value;
	_animatorClose.contentToAnim = _content;
}

Dans le dernier article portant sur les design patterns en ActionScript3 , nous avons abordée la factory. Aujourd’hui voyons l’Abstract factory (fabrique abstraite). Elle encapsule un groupe de factory ayant une thématique commune. Le code crée une implémentation concrète de la fabrique abstraite, puis utilise les interfaces génériques pour créer des objets concrets de la thématique. Le client ne se préoccupe pas de savoir laquelle de ces fabriques a donné un objet concret, car il n’utilise que les interfaces génériques des objets produits. Ce patron de conception sépare les détails d’implémentation d’un ensemble d’objets de leur usage générique.

Exemple de mise en œuvre :

private var _contenu0:IContenu;
private var _contenu1:IContenu;
private var _contenu2:IContenu;

public function creator(content:Object)
{

/*
ABSTRACT FACTORY
factory utilise d'autres factory , cache les classes fabricant l'objet
*/

_contenu1 = FactoryContent.prebuild(content);
_contenu2 = FactoryContent.prebuild(_content);

}

Contenu de la classe FactoryContent :

public class FactoryContent
{
public function FactoryContent()
{
}

public static function prebuild(content:Object):IContenu
{
var resultatContenu:IContenu;

resultatContenu = BContenu.prebuildContent(content);

return resultatContenu;
}

}

on peut toujours construire des contenus “from scratch”  sans factory :

_contenu0 = BContenu.prebuildContent(_content);
_contenu1 = BContenu.prebuildContent(_content);
_contenu2 = BContenu.prebuildContent(_content]);

public static function prebuildContent(content:Object):IContenu
{
var resultatContenu:IContenu;
resultatContenu = new BContenu(content);

return resultatContenu;
}