onClipEvent (enterFrame) {

   if (_x>-15) {

       _x=_x-4;

   } else {

       _x=500;

   }

}

Wenn horizontale Position größer ist als -15, wandert das Schaf

pro Frame 4 Pixel nach rechts:

_x=_x-4;

Andernfalls wird das Schaf wieder an den rechten Rand gesetzt:

 _x=500

programmierte Bewegung

Der Movieclip bewegt sich, indem der derzeitigen Position der Wert der Variablen xdir bzw. ydir hinzugezählt wird. In den if Abfragen wird überprüft ob _x und _y Position kleiner bzw. größer ist als der Rand. Sollte das der Fall sein, wird xdir bzw. ydir dementsprechend geändert, so daß sich die Filmsequenz in die andere Richtung bewegt. Beide Beispiele führen zu dem selben Ergebnis.

onClipEvent (load) {

xdir = 4;

ydir = 4;

}

onClipEvent (enterFrame) {

_x = _x+xdir;

if (_x<10) {

xdir = 4;

} else if (_x>200) {

xdir = -4;

}

_y = _y+ydir;

if (_y<10) {

ydir = 4;

} else if (_y>200) {

ydir = -4;

}

}

onClipEvent (load) {

   xdir = 6;

   ydir = 4;

}

onClipEvent (enterFrame) {

   _x = _x+xdir;

   if ((_x<10) || (_x>200)) {

       xdir = xdir*-1;

   }

   _y = _y+ydir;

   if ((_y<10) || (_y>200)) {

       ydir = ydir*-1;

   }

}

Das Quadrat (instanz quad) läßt sich mit den Peiltasten verschieben, allerdings sollte die Kugel innen bleiben, sonst funktioniert es nicht. Wir haben hier die gleichen Actions wie zuvor in abgewandelter Form. Der linke Rand des Quadrats wird durch seine horizontale Position _x minus die Hälfte seiner Breite _width/2 definiert. Außerdem wird noch die Hälfte der Breite der Kugel hinzugefügt, damit nicht der Mittelpunkt der Kugel abprallt. Also haben wir für den linken Rand folgenden Wert in der if else Abfrage:

(_root.quad._x-_root.quad._width/2)+_width/2

Die anderen Ränder, werden dann in ähnlicher Weise definiert.

onClipEvent (load) {

   xdir = 4;

   ydir = 2;

}

onClipEvent (enterFrame) {

   _x = _x+xdir;

   if ((_x<(_root.quad._x-_root.quad._width/2)+_width/2) || (_x>(_root.quad._x+_root.quad._width/2)-_width/2)) {

       xdir = xdir*-1;

   }

   _y = _y+ydir;

   if ((_y<(_root.quad._y-_root.quad._height/2)+_height/2) || (_y>(_root.quad._y+_root.quad._height/2)-_height/2)) {

       ydir = ydir*-1;

   }

}

Hier geht es um die Positionierungen eines MCs mittels der Mausposition. Die beiden ersten MCs haben ihren Mittelpunkt, links wo das M steht. Wenn die Maus den Weg der Bühne von 550 Pixeln zurückgelegt hat, soll der Film den Weg seiner eigenen Weite zurücklegen. Um das zu erreichen, wird die Weite des Films durch die Bühnenweite geteilt und dieser Wert mit der Mausposition mulitipliziert. Da der Film sich in gegengesetzter Richtung bewegen soll, wird das Ganze mit -1 multipliziert. Siehe Actionscript oben.

onClipEvent (enterFrame) {

_x=((_width/550)*(_root._xmouse))*-1;

}

Wie man sieht , haben wir oben allerdings noch kein optimales Ergebnis, denn der rechte Rand des Films wandert am Ende zu weit nach  links. Was passiert hier? Der Film legt zwar den Weg seiner gesamten Weite zurück, aber da liegt schon der Hund begraben, denn er soll nicht ganz so weit gehen. Beim genauen Betrachten, sieht man, dass genau die Breite der Bühne zuweit zurückgelegt wurde. Also muß dieser Wert noch subtrahiert werden.

onClipEvent (enterFrame) {

_x = (((_width-550)/550)*(_root._xmouse))*-1+(_width/2);

}

Bei diesem MC liegt der Mittelpunkt wie üblich in der Mitte, also wird der X-Position noch die halbe Weite hinzuaddiert.

onClipEvent (enterFrame) {

_x=(((_width-550)/550)*(_root._xmouse))*-1;

}

onClipEvent (load) {

/:xziel = 72;

/:yziel = 72;

}

onClipEvent (enterFrame) {

_x = _x+(/:xziel-this._x)/6;

_y = _y+(/:yziel-this._y)/6;

}

on (rollOver) {

/:xziel = 36;

/:yziel = 108;

}

Der Filmsequenz (Quadrat aussen) wurde obenstehendes Actionscript zugewiesen.

Die jeweilige Zielposition, wird per Button vergeben, /:xziel und /:yziel. Nun kommt der Trick. Anstatt, daß der Movieclip einfach die neue Position einnimmt, _x=/:_xziel bewegt er sich dynamisch darauf zu. Dazu braucht man erstmal den Abstand des Movieclips zu dieser Zielposition, indem man das Ziel einfach von der derzeitigen x bzw. y Position abzieht.

/:xziel-this._x  Mit folgender Formel würde der Film die Zielposition sofort einnehmen, da der derzeiten XPosition der Abstand zum Ziel hinzugefügt wird. _x+(/:xziel-this._x);  Dieser Abstand wird jedoch durch 6 geteilt und der derzeitigen Position hinzugefügt.

_x+(/:xziel-this._x)/6; Der Film legt somit ein 6tel der Strecke Richtung Ziel zurück. Beim nächsten on Enter Frame wird dieser mittlerweile geringere Abstand zum Ziel wieder durch 6 geteilt und der x Position hinzugefügt etc., so dass der Film sich immer mehr dem Ziel nähert. Anstatt durch 6 zu teilen, kann man selbstverständlich auch einen anderen Wert einsetzen, je nach gewünschter Geschwindigkeit.

scroll und klick

Links ist ein mc mit einem button der mittels drag movie den mc bewegt. Außerdem wird dort eine Variable /:check (onPress) auf 1 gesetzt und( on release) auf 0.

Der Bilder MC hat das gleiche Script, wie 2 Seiten zuor erklärt, nur dass es hier in eine if Struktur eingebunden ist, die abfragt, ob /:check==1 ist. Also wird die horizontale Positionierung per _root._xmouse nur ausgeführt, wenn der Button gedrückt ist.

Die 3 Positions Buttons setzen die Variable /:check auf 2, dadurch kommt das Script ins Spiel, welches auf der vorigen Seite erklärt wird. Auch dieses Script wird im Bilder MC in eine if-Struktur eingebunden, hier muss /:check==2 sein, also einer der 3 Buttons gedrückt worden sein.

Zum Schluss wird noch der MC Instanzname Schieber auf die richtige x Position gesetzt.  Der Wert 1450 ist die Weite des MC minus die Bühnenweite. 550 ist die Weite der Bühne. Es macht Sinn, wenn man die Weite des Films durch ein transparentes Platzhalterbild definiert, so das der sichtbare Inhalt etwas kleiner ist als die tatsächliche Breite des MC. So bieten sich mehr Möglichkeiten.

onClipEvent (enterFrame) {

if (/:check==1) {

_x = (((_width-550)/550)*(_root._xmouse))*-1;

} else if (/:check==2) {

_x = _x+(/:xziel-this._x)/6;

_root.schieber._x = (_x*-1/1450)*550;

}

}

on (release) {

/:check = 2;

/:xziel = -20;

}

on (press) {

/:check = 1;

startDrag("", true, 8, 65, 542, 65);

}

on (release, releaseOutside, dragOut) {

/:check = 0;

stopDrag();

}

on (release) {

/:check = 2;

/:xziel = -725;

}

on (release) {

/:check = 2;

/:xziel = -1435;

}

Hier wird eine programmierte Bewegung mittels sinus erzeugt. Der Sinuswert einer Zahl liegt immer zwischen +1 und -1. Anstatt einen Wert in die Klammer von Math.sin() einzutragen steht hier die Kurzform der Variablen i=i+0.09. Je größer der Faktor desto kürzer ist die Pendelbewegung.

*50 erzeugt einen Ausschlag von -50 zu +50      +100 versetzt die Achse.

X Position mittels if / else siehe erste Seite.

onClipEvent (enterFrame) {

   _y = Math.sin(i += 0.09)*50+100;

   if (_x<600) {

       _x = _x+3;

   } else {

       _x = -50;

   }

}

sinus cosinus

onClipEvent (enterFrame) {

   if (z<100) {

       z++;

       duplicateMovieClip (this, "kugel"+z, z);

       _root["kugel"+z]._y=Math.sin(e += 0.18)*50+320;

       _root["kugel"+z]._x=z*7;

   } else {

       for (z=0; z<=100; z++) {

           removeMovieClip (_root["kugel"+z]);

       }

       z=0;

       e=0;

   }

}

_y = Math.sin(i += 0.09)*50+100;

_x = Math.sin(e += 0.09)*50+xMittelpunkt;

_y = Math.cos(i += 0.09)*50+100;

_x = Math.sin(e += 0.09)*50+xMittelpunkt;

yx

Auf der linken Seite wurden für x und y die gleichen sinus Formeln eingegeben. Wie man am dritten Beispiel sehen kann läßt sich damit keine Kreisbewegung erstellen, denn wenn x und y gleich sind, hat man immer eine diagonale Bewegung. Wenn x klein ist müßte y groß sein und umgekehrt. Genau das passiert im Verhältnis von sin zu cos.

Um eine Kreisbewegung zu erzeugen muß sin und cos kombiniert werden. Die erste Kugel im rechten Bereich hat die y Bewegung mit cos bekommen. Bei den letzten beiden Kugeln ist die x Bewegung die gleiche wie auf der linken Seite.

300400

Die Länge einer Schwingung oder Umdrehung beträgt immer 2*pi. Also lässt sich die  Dauer einer Umkreisung in Bildern (Frames) berechnen, in dem man 2*pi durch a teilt, also: T=2*pi/a.

Andersherum bedeutet das , dass man die Schwingungs- bzw. Drehdauer  in Frames ganz leicht selbst festlegen kann.

Hierzu muss man nur 2*pi durch die gewünschte Frameanzahl teilen und das Ergebnis als Schrittweite angeben.

a=2*math.Pi/Frames pro Umdrehung;

onClipEvent (enterFrame) {

   a=2*math.Pi/_root.eingabe;

   i = i+a;

   _x=400-math.sin(i)*100;

   _y=250-math.cos(i)*100;

}

on (release, keyPress "<Down>") {

   /:rou = 16;

   /:ou = 1;

}

on (keyPress "<Up>") {

   /:rou = 16;

   /:ou = -1;

}                   

on (release, keyPress "<Right>") {

   /:rlr = 16;

   /:lr = 1;

}

on (keyPress "<Left>") {

   /:rlr = 16;

   /:lr = -1;

}

rlr und rou wird pro Frame um 2 verkleinert, bis es 0 ist.

Der Wert wird zur x und y Position addiert, so dass auf Tastendruck ein Schub entsteht. Durch multiplizieren mit +1 oder -1 (lr bzw. ou) wird die Bewegung nach links und rechts bzw. nach oben und unten ausgeführt.

onClipEvent (enterFrame) {

   if (/:rlr>0) {

       /:rlr = /:rlr-2;

   }

   this._x=_x+/:rlr*/:lr;

   if (/:rou>0) {

       /:rou = /:rou-2;

   }

   this._y=_y+/:rou*/:ou;

}

Bewegung per Pfreiltasten

onClipEvent (enterFrame) {

   if ((Key.isDown(Key.RIGHT))&&this._x<500) {

       this._x = _x+/:sspeed;

   } else if (key.isDown(Key.LEFT)&&this._x>40) {

       this._x = _x-/:sspeed;

   }

   if ((Key.isDown(Key.DOWN))&&this._y<370) {

       this._y = _y+/:sspeed;

   } else if (key.isDown(Key.UP)&&this._y>40) {

       this._y = _y-/:sspeed;

   }

}

onClipEvent (load) {

   /:sspeed = 10;

}

Ab Flash MX kann man auch das key Objekt für Tastatur befehle verwenden

Das Schiff läßt sich mit den Pfeiltasten steuern.

Man kann sich auch die beiden zuvor erklärten Möglicheiten miteinander kombinieren. Lade die folgenden Beispiefilm