Alphatween

[Wanderratte]

Ich habe heute durch Zufall einen alten Thread wiedergefunden,
in dem StephanF ein Script komplett Dokumentiert hat.
Ich wollte es euch nicht vorenthalten.
Danke nochmal an StephanF

/* 
Vorüberlegungen: Was sehen wir und was wollen wir erreichen?? 
Wir sehen: 
Mehere weiße Balken bewegen sich über ein beliebiges Hintergrundbild. 
Die Bewegungen werden bei genauer Betrachtung immer etwas anders ausgeführt, sprich 
"zufällig". Während sich die Balken von rechts nach links(und umgekehrt) bewegen, 
also Ihre _x-Position verändern, werden sie zugleich auch etwas schmaler oder breiter(_width, _xscale). 
Als letztes fällt uns auf, das die Balken sich langsam ein- u. ausblenden(Transparent werden). 

Wir wollen: 
eigentlich das gleiche wie oben, und noch ein wenig mehr: 
zusätzlich wollen wir ja auch bestimmen können, wie breit unser Bild ist und 
wie schnell das ganze ablaufen soll. 
Wir wissen was wir brauchen:--> 
(Wir befinden uns in Frame 1.) 
-->Ein beliebiges Hintergrundbild, welches wir auf der untersten Ebene an den Positionen x=0, y=0 
auf der Bühne platzieren. Wir aktivieren anschließend das Schloß auf der untersten Ebene, 
um hier weitere ungewollte Aktionen zu vermeiden. 
Nun klicken wir einmal in der Zeitleiste auf Ebene 2 in das erste Frame 
--> einen weißen Balken, welchen wir mit dem Rechteckwerkzeug 
aus der Werkzeugpalette zeichnen können. 
Damit wir den "weißen Balken" auch nutzen können, 
wandeln wir Ihn in ein Symbol um. Dies erreichen wir, wenn wir - der Balken muß makiert sein - 
F8 drücken, dem Symbol einen sinnvollen Namen geben, die Registrierung auf links-oben setzen und 
darauf achten, daß MovieClip aktiviert ist. 

--> Variablen 
//Diese werden alle IM Schlüsselbild auf der obersten Ebene eingefügt, NICHT AUF den MC 
*/ 
/*Wie schnell soll sich der Balken (nachfolgend "MC" genannt) in seiner Breite verändern. 
Da sich alles in einem Frame abspielt, sind wir uns darüber im klaren, mit je mehr BPS der fertige 
Flash-Film veröffentlich wird, um so öffter wird der Frame auch pro Sekunde aufgerufen und dem entsprechen 
wirkt sich das auf das Verhalten unserer Variablen und das Aussehen unseres Movies aus. 
*/ 
//Unsere Variable für die Geschwindigkeit der Skalierung (breiter, schmaler) 
scaleSpeed = 1; 
//Unsere Variable für die größte x-Position des MC. Ergo wäre hier ein Bild von 800 Pixeln Breite angebracht 
xMax = 800; 
//Die Geschwindigkeit der Bewegung des MC nach rechts und links 
xSpeed = 2; 
//Der Maximale AlphaWert für den Transparenz Effekt 
alphaMax = 100; 
//Wie schnell soll der Alphawert erhöht oder verringert werden 
aSpeed = 1; 
//Maximale Vergrößerung (Breite) des MC 
scaleMax = 150; 

/*Der gesamte folgende Code kommt auf den MC. Also den Balken-MC durch anklicken 
markieren und dann im Aktionen-Fenster (Expertenmodus) einfügen. 
*/ 
//Wenn unser MC geladen wird 
onClipEvent (load) 
{ 
    /* 
    Anfangs wurde mal über "zufällig" gesprochen. Das erledigt für uns "random", 
    es ermttelt für uns eine Zufallszahlm mit der wir dann arbeiten können. Diese könnte man auch in größe und 
    Reichweite durch Parameterange begrenzen, würde hier aber zu weit führen. 
    Anders ausgedrückt, wenn wir im folgenden Code alle "random" durch eine Ganzzahl 
    ersetzen würden, wäre unser Erscheinungsbild immer gleich und der Ablauf ebenfalls. 
    */ 
    //dieser(this) MC bekommt eine neue zufällige xPosition, die nicht größer sein kann 
    //als 800, da wir die Variable "xMax" im Schlüsselbild auf 800 festgelegt haben 
    this.XNew = random(xMax) + 1; 
    //das gleiche gilt für den AlphaWert 
    this.Alpha = random(alphaMax) + 1; 
    //und auch für den Wert der  Breite 
    this.XScale = random(scaleMax) + 1; 
} 
//Wenn der MC wieder das Frame betritt 
onClipEvent (enterFrame) 
{ 
    //Wenn(if)MC xPosition gleich der neuen Zufallsposition 
    if (this._x == this.XNew) 
    { 
        //Dann ermittle mit random eine neue Position 
        this.XNew = random(_root.xMax) + 1; 
    } // end if 
    //Wenn MC xPosition kleiner als (<) zufallXnew 
    if (this._x < this.XNew) 
    { 
        //Dann bewege MC xPosition gemäß der Geschwindigkeit xSpeed 
        //nach RECHTS(this._x + _root.xSpeed) 
        this._x = this._x + _root.xSpeed; 
        //Sobald aber aktuelle xPosition größer oder gleich als XNew ist 
        if (this._x >= this.XNew) 
        { 
            //ermittle wieder eine neue 
            this.XNew = random(_root.xMax) + 1; 
        } // end if 
    } // end if 
    //jetzt drehen wir den Spieß um 
    //Wenn zufallXnew kleiner als (<)MC xPosition   
    if (this.XNew < this._x) 
    { 
        //Dann bewege MC xPosition gemäß der Geschwindigkeit xSpeed 
        //nach LINKS(this._x - _root.xSpeed)         
        this._x = this._x - _root.xSpeed; 
        if (this.XNew >= this._x) 
        { 
            //ermittle wieder eine neue 
            this.XNew = random(_root.xMax) + 1; 
        } // end if 
    } // end if 
//     
//Nun machen wir das selbe mit den Alphawerten 
//und der Mc wird Heller oder dunkler 
//Was sich oben noch bewegt hat wird jetzt halt Transparent 
// 
    if (this._alpha == this.Alpha) 
    { 
        this.Alpha = random(_root.alphaMax) + 1; 
    } // end if 
    if (this._alpha < this.Alpha) 
    { 
        this._alpha = Math.round(this._alpha + _root.aSpeed); 
        if (this._alpha >= this.Alpha) 
        { 
            this.Alpha = random(_root.alphaMax) + 1; 
        } // end if 
    } // end if 
    if (this.Alpha < this._alpha) 
    { 
        this._alpha = Math.round(this._alpha - _root.aSpeed); 
        if (this.Alpha >= this._alpha) 
        { 
            this.Alpha = random(_root.alphaMax) + 1; 
        } // end if 
    } // end if 
// 
//Und hier die Verwendung für unseren dritten Effekt, der Skalierung 
//gleiche Vorgehensweise wie mit der Position und dem Alphawert 
// 
    if (this._xScale == this.XScale) 
    { 
        this.XScale = random(_root.scaleMax) + 1; 
    } // end if 
    if (this._xScale < this.XScale) 
    { 
        this._xScale = this._xScale + _root.scaleSpeed; 
        if (this._xScale >= this.XScale) 
        { 
            this.XScale = random(_root.scaleMax) + 1; 
        } // end if 
    } // end if 
    if (this.XScale < this._xScale) 
    { 
        this._xScale = this._xScale - _root.scaleSpeed; 
        if (this.XScale >= this._xScale) 
        { 
            this.XScale = random(_root.scaleMax) + 1; 
        } // end if 
    } // end if 
} 

Zu dem Orinalthread geht es hier lang