Classe "easeTime" [AS3]

[Stan]

Qualche giorno fa avevo chiesto aiuto per la scrittura di una classe, questo è quello che è venuto fuori

Si può convertire molto facilmente in AS2

/*
#################
# Name: easeTime Class
# Author: Pomili Alessandro
# Date: 17 Nov 20009
# Description: La classe restituisce un array nel quale gli indici contengono un intervallo di numeri, con progressione calcolata sulle funzione di ease
###########

*/


package {
    import fl.transitions.easing.Regular;
    public class easeTime {
        public function easeTime ():void {
            throw (new Error("La classe è di tipo singleton e non può essere istanziata"));
        }
		//restituisce un intervallo tra delay e tempo (es tra 0 e 5,  o tra 3-7)
        public static function getTime(elementi:Number, myease:Function=null, tempo:Number=1, delay:Number=0):Array {
            var arrayTempo = new Array();
            if (myease==null) { myease = Regular.easeOut}; 
			for (var i:uint = 1; i <= elementi; i++) {				
				//myease(i, delay, ((i/elementi)/i)*elementi, elementi)*tempo // questa istruzione calcola il valore di ease sul numero degli elementi tra l'intervallo di tempo 0, e tempo)
				arrayTempo.push (Math.round(myease(i, delay/tempo, ((i/elementi)/i)*elementi, elementi)*tempo*1000)/1000); //round*1000/1000 arrotonda a 3 decimali
			}
            return arrayTempo;
        }
		//restituisce un intervallo tra tempo e delay
		public static function getTimeOff(elementi:Number, myease:Function=null, tempo:Number=1, delay:Number=0):Array {
			var arrayTempo:Array = getTime(elementi, myease, tempo, delay)
			return arrayTempo.reverse()
		}		
		
		//restituisce un intervallo dove i lati dell'array contengono gli intervalli più piccoli
		public static function getTimeCenter(elementi:Number, myease:Function=null, tempo:Number=1, delay:Number=0, blReverse:Boolean=false):Array {
			var meta_elementi:Number = Math.ceil(elementi/2)
			var arrayMetaTempo:Array = new Array()
			if (blReverse){
				arrayMetaTempo = getTime(meta_elementi, myease, tempo, delay)
			}else{
				arrayMetaTempo = getTimeOff(meta_elementi, myease, tempo, delay)
			}
			var reverse:Array = reverse(arrayMetaTempo)
			if (elementi%2!=0){			//se gli elementi sono dispari tolgo il primo indice
				reverse.shift()
			}	
			var arrayTempo:Array=arrayMetaTempo.concat(reverse)
			return arrayTempo
		}
		
		//restituisce un intervallo dove i lati dell'array contengono gli intervalli più grandi		
		public static function getTimeSide(elementi:Number, myease:Function=null, tempo:Number=1, delay:Number=0):Array {
			return getTimeCenter(elementi, myease, tempo, delay, true)
		}
		
		//crea una copia inversa dell'array passato
		private static function reverse(arrayTempo:Array):Array {
			var reverse:Array = new Array()
			reverse = reverse.concat(arrayTempo)
			return reverse.reverse()
		}
	}

Uso

import com.greensock.*;
import com.greensock.easing.*
import fl.transitions.easing.*;

var elementi:Number=10

var ease:Function = Regular.easeOut
var durata:Number = 10
var delay:Number = 1

var tempo = easeTime.getTime(elementi, ease, durata, delay)
//tempo = easeTime.getTimeOff(elementi, ease, durata, delay)
//tempo = easeTime.getTimeSide(elementi, ease, durata, delay)
//tempo = easeTime.getTimeCenter(elementi, ease, durata, delay)

trace(tempo)
/*
for (var i=0;i<elementi;i++){
	var cc:Cerchio = new Cerchio()
	cc.x = (cc.width+5)*i
	cc.y = stage.stageHeight-cc.height;
	addChild(cc)
	TweenLite.from(cc, 2, {y:"-550", ease:Regular.easeOut, delay:tempo[i]})
}*/

Magari può esservi utile, se riscontrate qualche problema, o se avete in mente altri tipi effetti fatemi sapere

[crescenzo]

beh si può vedere un es....dato che uso AS2

thx

[Stan]

Ehm...dovrei upparli a qualche parte, ci lavoro nel we magari

[whisher]

Originariamente inviato da Stan
Magari può esservi utile, se riscontrate qualche problema, o se avete in mente altri tipi effetti fatemi sapere

Utile senz'altro
grazie per lo spunto

Però ad essere pignoli la classe un singleton non è
per fare un singleton dovresti inserire una variabile
statica

package {
   
   public class SingletonDemo {
      private static var instance:SingletonDemo;
      private static var allowInstantiation:Boolean;
      
      public static function getInstance():SingletonDemo {
         if (instance == null) {
            allowInstantiation = true;
            instance = new SingletonDemo();
            allowInstantiation = false;
          }
         return instance;
       }
      
      public function SingletonDemo():void {
         if (!allowInstantiation) {
            throw new Error("Error: Instantiation failed: Use SingletonDemo.getInstance() instead of new.");
          }
       }
    }
} 

http://www.gskinner.com/blog/archive...ingletons.html

[and80]

Per me va bene, quello che ha usato è un modo diverso di scrivere una singleton, senza inserire un riferimento d'istanza, che è utile in quei casi in cui sia necessario creare un'istanza e richiamare metodi non statici.
Io le scrivo in entrambi i modi a seconda di quello che devo fare, in questo caso trovo che vada bene scriverla così.

[edit] Nello stesso post che hai linkato ci sono una serie di spunti tra i commenti che dibattono su quale sia il metodo migliore di scrivere una singleton o una classe a metodi statici, il che dimostra quanto siano molteplici i modi di vedere e gestire questo tipo di classi.

[Stan]

Non sono molto pratico con le classi ^^
Con gli scope a volte mi ci perdo addirittura.

Tra l'altro ho visto che mentre scrivevo i post ci ho lasciato le parole ahah.

[Stan]

Versione AS2

import mx.transitions.easing.Regular;

class easeTime {
	/*private var __time:Array;
	private var __elementi:Number;
	private var __inizio:Array
	private var __tempo:Number*/
	
	public function easeTime () {
		throw (new Error("La classe è di tipo singleton e non può essere istanziata"));
	}
	//restituisce un intervallo tra delay e tempo (es tra 0 e 5,  o tra 3-7)
	public static function getTime(elementi:Number, myease:Function, tempo:Number, delay:Number):Array {
		var arrayTempo = new Array();
		if (myease==null || myease==undefined) { myease = Regular.easeOut};
		if (tempo==undefined) { tempo = 1};
		if (delay==undefined) { delay = 0};
		for (var i:Number = 1; i <= elementi; i++) {				
			//myease(i, delay, ((i/elementi)/i)*elementi, elementi)*tempo // questa istruzione calcola il valore di ease sul numero degli elementi tra l'intervallo di tempo 0, e tempo)
			arrayTempo.push (Math.round(myease(i, delay/tempo, ((i/elementi)/i)*elementi, elementi)*tempo*1000)/1000); //round*1000/1000 arrotonda a 3 decimali
		}
		return arrayTempo;
	}
	//restituisce un intervallo tra tempo e delay
	public static function getTimeOff(elementi:Number, myease:Function, tempo:Number, delay:Number):Array {
		var arrayTempo:Array = getTime(elementi, myease, tempo, delay)
		arrayTempo.reverse()
		var reversed:Array = arrayTempo
		return reversed
	}		
	
	//restituisce un intervallo dove i lati dell'array contengono gli intervalli più piccoli
	public static function getTimeCenter(elementi:Number, myease:Function, tempo, delay, blReverse:Boolean):Array {
		var meta_elementi:Number = Math.ceil(elementi/2)
		var arrayMetaTempo:Array = new Array()
		if (blReverse){
			arrayMetaTempo = getTime(meta_elementi, myease, tempo, delay)
		}else{
			arrayMetaTempo = getTimeOff(meta_elementi, myease, tempo, delay)
		}
		var reversed:Array = reverse(arrayMetaTempo)
		if (elementi%2!=0){			//se gli elementi sono dispari tolgo il primo indice
			reversed.shift()
		}
		var arrayTempo:Array=arrayMetaTempo.concat(reversed)
		return arrayTempo
	}
	
	//restituisce un intervallo dove i lati dell'array contengono gli intervalli più grandi		
	public static function getTimeSide(elementi:Number, myease:Function, tempo:Number, delay:Number):Array {
		return getTimeCenter(elementi, myease, tempo, delay, true)
	}
	
	//crea una copia inversa dell'array passato
	private static function reverse(__arrayTempo:Array) {		
		var reversed:Array = new Array()
		reversed = reversed.concat(__arrayTempo)
		return reversed.reverse()		
	}
}

[crescenzo]

grande...appena ho attimo la provo......

[whisher]

Originariamente inviato da and80
Per me va bene, quello che ha usato è un modo diverso di scrivere una singleton, senza inserire un riferimento d'istanza, che è utile in quei casi in cui sia necessario creare un'istanza e richiamare metodi non statici.
Io le scrivo in entrambi i modi a seconda di quello che devo fare, in questo caso trovo che vada bene scriverla così.

[edit] Nello stesso post che hai linkato ci sono una serie di spunti tra i commenti che dibattono su quale sia il metodo migliore di scrivere una singleton o una classe a metodi statici, il che dimostra quanto siano molteplici i modi di vedere e gestire questo tipo di classi.

Grazie per info.
Capisco il punto di vista
ma il singleton è un singleton
se no è qualcos'altro imho.
Ad ogni modo mi leggo i commenti
hai visto mai