Eventi personalizzati - classe DispatchEvent

[Flep]

Augh!
Dopo svariati tutorials e articoli e dopo altrettante utilità gratuite messe a disposizione con i codici sorgente, chiunque di voi si fosse impegnato in uno studio approfondito del package flash.events avrà sicuramente adesso una buona dimestichezza con i metodi addEventListener e removeEventListener di Actionscript 3.0.
Detto questo, è giunto il momento di approfondire su come creare degli eventi personalizzati con Actionscript 3.0... eventi personalizzati ?*
Sì, con*Actionscript 3.0*( potevamo farlo già con Actionscript 2.0 ) si possono creare degli eventi che non fanno parte del package flash.events. O meglio, in questo tutorial vedremo come aggiungere un evento alla classe built-in Event, creando una nostra classe, sottoclasse di DispatchEvent, quindi che estende DispatchEvent e ne eredita metodi e proprietà.
Quindi, ad esempio, sappiamo che la classe Event ha un evento chiamato ENTER_FRAME. Noi andremo ad aggiungere a quella classe gli eventi EVENTO_UNO ed EVENTO_DUE, gestendoli a nostro piacere.

Vediamo come fare...

Creo un FLA che salvo con nome ' main.fla '.
Al suo interno creo una MovieClip di qualsiasi forma, che istanzio sullo stage assegnadole nome istanza ' clip_mc '.

Creo la Document Class, un file AS che salvo con nome ' Manager.as ', implementata in questo modo:

package
{
	import flash.display.MovieClip;
	import flash.events.Event;
	
	public class Manager extends MovieClip
	{
		private var movement:Movement;
		
		public function Manager()
		{
			init();
		}
		
		private function init():void
		{
			stage.frameRate=31;
			
			movement=new Movement(this);
			movement.addEventListener(Movement.EVENTO_UNO,partito);
			movement.addEventListener(Movement.EVENTO_DUE,arrivato);
			movement.addEventListener(Movement.EVENTO_TRE,tornato);
			movement.parti();
		}
		
		private function partito(e:Event):void
		{
			trace('partito');
		}
		
		private function arrivato(e:Event):void
		{
			trace('arrivato');
		}
		
		private function tornato(e:Event):void
		{
			trace('tornato');
		}
	}
}

Analizziamo il codice

Proprietà
una istanza della classe Movement che andremo a creare più avanti
private var movement:Movement;

Metodi
init();
imposto la velocità del frame rate
stage.frameRate=31;
istanzio la classe Movement
movement=new Movement(this);
ecco un punto importantissimo di questo tutorial. Come si nota, aggiungo un listener all' istanza movement. Sappiamo che addEventListener vuole almeno 2 parametri e cioè un evento e il nome del metodo da chiamare quando l' evento è scaturito. In una situazione ' normale ' ci troveremmo in questa sintassi: my_mc.addEventListener(Event.ENTER_FRAME,partito); invece , per creare un evento personalizzato in più alla classe Event, passiamo come parametro una proprietà statica della classe Movement ( che vedremo ) ed il nome del metodo da chiamare ( partito ). Quindi, ad un dato evento verrà chiamato il rispettivo metodo ( e quì niente di nuovo ).
movement.addEventListener(Movement.EVENTO_UNO,part ito);
movement.addEventListener(Movement.EVENTO_DUE,arri vato);
movement.addEventListener(Movement.EVENTO_TRE,torn ato);
chiamo un metodo della classe Movement che come possiamo capire è un metodo non statico in quanto viene chiamato dall' istanza della classe stessa.
movement.parti();

Ora passiamo a vedere la classe Movement.
Creo un file AS che salvo con nome ' movement.as ', implementato in questo modo:

package
{
	import flash.display.MovieClip;
	import flash.events.EventDispatcher;
	import flash.events.Event;
	
	public class Movement extends EventDispatcher
	{
		private var _fla:MovieClip;
		
		private var arrX:int=400;
		
		public static const EVENTO_UNO:String='eventoUno';
		public static const EVENTO_DUE:String='eventoDue';
		public static const EVENTO_TRE:String='eventoTre';
		
		public function Movement(fla:MovieClip)
		{
			_fla=fla;
		}
		
		public function parti():void
		{
			dispatchEvent(new Event(Movement.EVENTO_UNO));
			_fla.clip_mc.addEventListener(Event.ENTER_FRAME,go);
		}
		
		private function go(e:Event):void
		{
			var dx:Number=arrX-e.target.x;
			var ax:Number=dx*.2;
			e.target.x+=ax;
			if(Math.abs(dx)<=.2)
			{
				e.target.x=arrX;
				dispatchEvent(new Event(Movement.EVENTO_DUE));
				e.target.removeEventListener(Event.ENTER_FRAME,go);
				arrX=25;
				e.target.addEventListener(Event.ENTER_FRAME,back);
			}
		}
		
		private function back(e:Event):void
		{
			var dx:Number=arrX-e.target.x;
			var ax:Number=dx*.2;
			e.target.x+=ax;
			if(Math.abs(dx)<=.2)
			{
				e.target.x=arrX;
				dispatchEvent(new Event(Movement.EVENTO_TRE));
				e.target.removeEventListener(Event.ENTER_FRAME,back);
			}
		}
	}
}

Analizziamo il codice
Da notare che le classe Movement estende la classe built-in DispatchEvent.
Proprietà
una istanza MovieClip a cui assegno la root passata dalla Document Class ( Manager.as ) in modo che possa recuperare la clip_mc che ho sullo stage.
private var _fla:MovieClip;
una variabile numercia che contiene il valore della x di arrivo durante uno spostamento di clip_mc utilizzando un effetto inerzia.
private var arrX:int=400;
Ecco le 3 proprietà statiche e pubbliche di questa classe. Quando dalla Document Class abbiamo aggiunto i listeners all' istanza appunto di questa classe, lo abbiamo fatto chiamando queste tre proprietà che contengono un valore stringa ( così come ad esempio l' evento built-in Event.ENTER_FRAME contiene un valore stringa 'enterFrame' ).
public static const EVENTO_UNO:String='eventoUno';
public static const EVENTO_DUE:String='eventoDue';
public static const EVENTO_TRE:String='eventoTre';

Metodi
parti();
dalla Document Class viene chiamato questo metodo per fare partire l'animazione ( spostamento sull' asse x tramite effetto inerzia ) di clip_mc, però prima di azionare l' ENTER_FRAME, dispacciamo EVENTO_UNO. Dispacciando questo evento, ricordiamoci che la Document Class ha un listener in ascolto di questo evento, per cui verrà chiamato il metodo segnalato al momento dell' aggiunta del listener ( partito ).
dispatchEvent(new Event(Movement.EVENTO_UNO));
_fla.clip_mc.addEventListener(Event.ENTER_FRAME,go );

go();
quì applico un effetto inerzia sull' asse x di clip_mc
var dx:Number=arrX-e.target.x;
var ax:Number=dx*.2;
e.target.x+=ax;
if(Math.abs(dx)<=.2)
{
e al momento opportuno imposto la x di clip_mc uguale al valore di arrX
e.target.x=arrX;
dispaccio un altro evento ( EVENTO_DUE ) che a sua volta sarà percepito dalla Document Class che ha un listener in ascolto di tale evento e chiamerà il rispettivo metodo da eseguire ( arrivato )
dispatchEvent(new Event(Movement.EVENTO_DUE));
rimuovo ENTER_FRAME
e.target.removeEventListener(Event.ENTER_FRAME,go) ;
cambio il punto di arrivo
arrX=25;
aggiungo un altro ENTER_FRAME che questa volta chiamerà il metodo back
e.target.addEventListener(Event.ENTER_FRAME,back);
}

back();
altro effetto dispostamento asse x di clip_mc
var dx:Number=arrX-e.target.x;
var ax:Number=dx*.2;
e.target.x+=ax;
if(Math.abs(dx)<=.2)
{
al momento opportuno imposto la x di clip_mc uguale al valore di arrX
e.target.x=arrX;
dispaccio un altro evento ( EVENTO_TRE ) che a sua volta sarà percepito dalla Document Class che ha un listener in ascolto di tale evento e chiamerà il rispettivo metodo da eseguire ( tornato )
dispatchEvent(new Event(Movement.EVENTO_TRE));
rimuovo ENTER_FRAME
e.target.removeEventListener(Event.ENTER_FRAME,bac k);
}

Ed ecco il risultato:

Allego i files sorgente: