[STUFF] transform Prototype

[querkopf]

Ihr wollt einen schnellen Alphafade?
...kein Problem.

Ihr wollt jetzt zusätzlich noch eine Skalierung???
...auch kein Problem!

Und jetzt auch noch eine Bewgung????!!!

Schaut Euch diesen Prototyp an:

der kann das ALLES!!!

(Erklärungen als Kommentare im as - FLA gibt's ganz unten)

// transform prototype by querkopf
// inspired by salazars fader ([url]http://www.flashforum.de/forum/showthread.php?t=138331[/url])
//
// Aufruf: 
// meinMovieclip.transform(schritte, abbremsen, eigenschaften, callback, variablen)
//
// schritte: number
// - die Schritte die festelegen um wieviel der Wert jeweils erhöht/verkleinert wird. (s. salazars fader)
// - wenn die Standardwerte verwendet werden sollen, einfach auf "null" setzen.
//
// abbremsen: number
// - der Wert der festlegt wie stark die Veränderung abgebremst werden soll .(s. salazars fader)
// - wenn die Standardwerte verwendet werden sollen, einfach auf "null" setzen.
//
// eigenschaften: object
// - die Objekteigenschaften die verändert werden sollen.
// - Zielwert wird hier definiert, als Ausgangswert wird immer der aktuelle Wert genommen.
// 
// callback (optional): function
// - Funktion die aufgerufen wird, wenn alle Veränderungen an "eigenschaften" abgeschlossen wurden.
// - liefert alle "eigenschaften" als object zurück
// - muß definiert sein, wenn "variablen" definiert sein sollen
//
// variablen (optional): object
// - ein Objekt mit beliebigen Variablen, die in "callback" über this angesprochen werden können
//
// BSP 1: ....................................................................................
// meinMovieclip._alpha = 0;
// meinMovieclip.transform(null, null, {_alpha:100});
// - ergibt einen einfachen Alphafade wie ihn salazar in seinem Beispiel bereits gebaut hatte
//
// BSP 2: ....................................................................................
// callback = function() {  
//    trace("fertig");
// };
// meinMovieclip._alpha = 0;
// meinMovieclip.transform(null, null, {_alpha:100}, callback);
// - ergibt einen Alphafade der bei Beendigung die Funktion "callback" aufruft
//
// BSP 3: ....................................................................................
// callback = function() {  
//    trace(this.id);
// };
// meinMovieclip._x = 0;
// meinMovieclip._alpha = 0;
// meinMovieclip.transform(null, null, {_alpha:100, _x:240}, callback, {id:"fertig"});
// - ergibt einen Alphafade der bei Beendigung die Funktion "callback" aufruft
// - zusätzlich wird der mc von _x:0 zu _x:240 bewegt 
// - in der "callback" Funktion wird das im Aufruf mit übergebene "id" getraced
//
Object.prototype.movement = function(val, fa, nr, st, br) {
    if (i == undefined) {
        i = 0;
    }
    if (this[val]>fa) {
        i += br;
        this[val] -= (st*i);
        if (this[val]<=fa) {
            this[val] = fa;
            this.a.splice(nr, 1);
        }
    } else if (this[val]<fa) {
        i += br;
        this[val] += (st*i);
        if (this[val]>=fa) {
            this[val] = fa;
            this.a.splice(nr, 1);
        }
    } else {
        this[val] = fa;
        this.a.splice(nr, 1);
    }
};
MovieClip.prototype.transform = function(va, st, obj, func, obj2) {
    var va = (typeof va == "null") ? 0.09 : va;
    var st = (typeof st == "null") ? 2 : st;
    var obj = (typeof obj == "object") ? obj : new Object();
    var mc = this;
    mc.a = new Array();
    for (o in obj) {
        if (typeof obj[o] != "function") {
            mc.a.push(o);
        }
    }
    mc.onEnterFrame = function() {
        if (this.a.length<=0) {
            delete this.onEnterFrame;
            return func.call(obj2, obj);
        } else {
            for (o=0; o<=this.a.length; o++) {
                if (this[this.a[o]] != obj[this.a[o]]) {
                    this.movement(this.a[o], obj[this.a[o]], o, va, st);
                }
            }
        }
    };
};
//
//
// BSP 4: ....................................................................................
this.callback = function(returnObj) {   
    for (o in returnObj) {
        trace(this.id+"."+o+": "+this.id[o]);
    }
};
this.mc.transform(0.09, 2, {_alpha:10, _xscale:200, _yscale:200, _x:240, _y:240}, callback, {id:this.mc});
stop(); 

[salazar]

daumen hoch! nettes teil...
ein gewisser as abschnitt kommt mir extrem bekannt vor
vor allem aber auch sehr ausführlich kommentiert und gut beschrieben. hier sollte es also keine, bzw kaum verständnis probs geben...

cya, sal

[querkopf]

thx

hab' mir noch überlegt, evtl könnte man den Aufruf von "va, st, obj" noch in " obj, va, st," umwandeln, dann reicht es z.B. mc.transform({_alpha:100}); zu schreiben....
aber das kann dann ja jeder nach seinem Geschmack anpassen

[nky]

hossa gefällt mir sehr gut !

thanx für die anregung !

Gruss nky

[psyk]

Kann mich meinen Vorrednern nur anschließen.

Nettes Teil.

[querkopf]

Danke, danke

[dante]

das script sieht sehr nützlich aus - ich denke ich könnte es bestimmt einsetzen, nur den code verstehe ich noch nicht ganz:

wenn die variable obj mit {wert,wert,wert} gefüllt wird, wie nennt man das?

for (o in obj) {
        if (typeof obj[o] != "function") {
            mc.a.push(o);
        }
    } 

formt alle inhalte von obj in ein array a um die inhalte ansprechen zu können, richtig?
(vielleicht ne dumme frage, aber warum darf o keine function sein?)

das ist der punkt wo ich noch nicht ganz durchblicke:

mc.onEnterFrame = function() {
        if (this.a.length<=0) {
            delete this.onEnterFrame;
            return func.call(obj2, obj);
        } else {
            for (o=0; o<=this.a.length; o++) {
                if (this[this.a[o]] != obj[this.a[o]]) {
                    this.movement(this.a[o], obj[this.a[o]], o, va, st);
                }
            }
        }
    }; 

für jedes element im array a wird etwas geprüft (( this[this.a[o]] != obj[this.a[o]] )) von dem ich nicht verstehe was es effektiv bedeutet (also die einzelteile sind mir klar nur wie sie zusammenhängen und warum das so gut ist, versteh ich nicht)

und dann falls "es" nicht gleich war (bloss was? ) wird die movement funktion mit this.a[o] (=was macht val in der funktion?) und obj[this.a[o]] (ist das nicht genau das selbe? was bedeutetd fa? ) aufgerufen.

sind alle bewegungen ausgeführt und es gibt keine elemente mehr im array wird onenterframe gelöscht und

return func.call(obj2, obj); 

aufgerufen.

wieso da jetzt call steht leuchtet mir nciht ein. was call genau macht verstehe ich ebenfals nicht
die flash hilfe sagt zu call:

In diesem Beispiel wird mit Function.call() dafür gesorgt, dass sich eine Funktion wie eine Methode eines anderen Objekts verhält, wobei die Funktion nicht im Objekt nicht gespeichert wird.

function MeinObjekt() {
}
function meineMethode(obj) {
trace("dies == obj? " + (dies == obj));
}
var obj = new MeinObjekt();
MeineMethode.call(obj, obj);

Die trace()-Aktion sendet den folgenden Code an das Bedienfeld Ausgabe:

dies == obj? true

was ich schon nciht verstehe. woher kommt "dies" ? übersetzungsfehler von this?
und was würde ich bekommen wenn ich in einer methode oder funktion (was ist der _genaue_ unterschied?) this aufrufe? das objekt auf dem die methode liegt? wenn eine funktion auf root liegt bekomme ich dann mit this nen verweis auf _root?

so viele fragen und ich bin nichtmal am ende von dem kleinen script angekommen

[le block]

danke,danke für das nette Teil. Ich kann's nämlich gerade gebrauchen.
Ich hätte da aber noch eine Frage dazu:

Und zwar verhält es sich so, dass es beim Bewegen (_x,_y) und gleichzeitigem Skalieren(_xscale,_yscale) zu (komischen) Rucklern kommt. also keine lineare Bewegung vom Startpunkt zum Endpunkt. Ich kann mir vorstellen,dass das mit a) der Skalierung zusammmenhängt und b) wenn die Differenzen der x,Y-Werte sich zu sehr unterscheiden. (Beispiel: xStart=20,xEnd=50->Diff=30; yStart=20,yEnd=500,Diff=480) Daher wird x eher erreicht als y.

Da ich aber genauso wie mein Vorposter eher in den Code schaue ,als verstehe, wollte ich Fragen: Wie erreicht man eine lineare (eher wohl geradlinige) Bewegung+Skalierung. (xEnd,yEnd,scaleEnd zur gleichen Zeit)?

Danke. le block

[querkopf]

...zur gleichen Zeit erreicht man das nur, wenn man das so dann neu programmiert

nee, im ernst... das wär' natürlich cool, wenn das dann gleichzeitig alles am endpunkt ankommt, das geht aber leider so, mit dem snippet nicht.

(eigentlich hatte ich das hier unter anderem auch gepostet, damit falls rein zufällig jemand auf die geniale Idee kommt, wie das zu lösen wär' das dann hier drunter schreibt )