Flash Tutorial: Sound-Spektrum mit AS 3

Noch vor einigen Jahren konnte man mit Flash das Sound-Spektrum nur faken, sprich, man zeichnete sich Balken oder Linien auf die Bühne und animierte diese per Hand. Das war natürlich kein zufriedenstellendes Ergebnis, also wurde in den Folgeversionen von Flash eine Sound,- und SoundMixer-Klasse eingeführt, die für solche Visualisierungen zuständig ist. Die in der SoundMixer-Klasse enthaltenen Methoden und Eigenschaften ermöglichen uns dabei auf die Soundsteuerung innerhalb eines Flash-Films zuzugreifen. Wir zeigen euch nun heute wie man mit Flash und AS3 ein Echtzeit Sound-Spektrum entwickelt.

1. Zunächst erstellen wir eine neue Flash-Datei (AS3). Speichern könnt ihr sie unter dem Namen spektrum.fla. Einen Sound benötigt ihr natürlich auch. Diesen legt ihr in dasselbe Verzeichnis in dem die spektrum.fla liegt.

2. Nun gehts auch schon ans programmieren. Der gesamte Code wird dabei ins erste Schlüsselbild der Hauptzeitleiste geschrieben. Wir initialisieren zuerst die Objekte die wir zur Darstellung des Spektrums benötigen:
var sound:Sound = new Sound();
var channel:SoundChannel = new SoundChannel();
var bytes:BitmapData = new BitmapData(256, 100, true, 0x000000);
var bitmap:Bitmap = new Bitmap(bytes);

3. Danach fügen wir das Bitmap der Anzeigeliste hinzu und positionieren es. Anschließend laden wir den Sound mithilfe von sound.load() und new URLRequest() und spielen ihn ab. Wichtig ist in AS3 das wir den Sound vorher dem Soundchannel hinzufügen:
addChild(bitmap);
bitmap.x = 150;
bitmap.y = 150;

sound.load(new URLRequest("sound.mp3"));
channel = sound.play();

4. Nun benötigen wir eine Funktion die das Abfragen des Spektrums ermöglicht. In der Funktion legen wir ein ByteArray an, das mit den Werten der Methode SoundMixer.computeSpectrum() befüllt wird. Die Werte werden als normalisierte Gleitkommawerte im Bereich zwischen -1,0 und 1,0 formatiert. Die Größe des erstellten ByteArray-Objekts ist auf 512 Gleitkommawerte festgelegt, wobei die ersten 256 Werte den linken Kanal darstellen und die restlichen 256 Werte den rechten Kanal. Zum Schluß wird das Bitmap in 2 for-Schleifen (für jeweils den linken und rechten Kanal) aktualisiert:
function onEnterFrame(event:Event):void {
var spectrum:ByteArray = new ByteArray();
SoundMixer.computeSpectrum(spectrum);
bytes.fillRect(bytes.rect, 0x000000);
for (var i:int = 0; i < 256; i++) {
bytes.setPixel32(i, 20 + spectrum.readFloat() * 20, 0xff000000);
}
for (var j:int = 0; j < 256; j++) {
bytes.setPixel32(j, 60 + spectrum.readFloat() * 20, 0xff000000);
}
};

5. Als letztes müssen wir die Funktion noch über einen ENTER_FRAME EventListener aufrufen um eine kontinuierliche Aktualisierung zu ermöglichen und fertig ist das Soundspektrum:
addEventListener(Event.ENTER_FRAME, onEnterFrame);

Flash Tutorial: TV-Rauschen mit AS 2

Heute zeigen wir euch wie man mit Flash und ein wenig Actionscript das bekannte TV-Rauschen erzeugt. Dazu bedarf es lediglich einem Bild von einem Fernseher in Frontansicht (entweder ihr zeichnet euch selbst einen oder schaut im Netz nach geeigneten Bildern), einer Schaltfläche und den Einsatz der BitmapData-Klasse und deren noise() Methode. Mit der noise() Methode kann man ein Bild mit zufällig platzierten Pixeln versehen und somit eignet sich die Methode wunderbar zur Darstellung des Effekts.

1. Zuerst erstellen wir uns eine neue Flash-Datei. Danach importieren wir in Flash das Bild vom Fernseher und platzieren es ins erste Schlüsselbild der Zeitleiste. Der Fernseher wird mittig auf der Bühne zentriert.

2. Wir erstellen eine neue Ebene und zeichnen in der Ebene ein schwarzes Rechteck, das genau deckungsgleich mit der Bildröhre des Fersehers ist. Danach wandeln wir das Rechteck in einen Movieclip um und geben ihm den Instanznamen “maske”.

3. Wir erstellen wieder eine neue Ebene. Nun müssen wir noch eine Schaltfläche zum ein- und ausschalten des Fernsehers erstellen. Dazu zeichnen wir ein Rechteck (20×20 px) in die neue Ebene und platzieren es mittig unter dem Fernseher. Das Rechteck wird wieder in einen Movieclip umgewandelt und bekommt den Instanznamen “button”.

4. Ab jetzt kommt Actionscript zum Einsatz. Wir erstellen uns nochmals eine neue Ebene und platzieren dort den Actionscript-Code.

5. Als erstes benötigen wir einen Platzhalter-Movieclip für das Rauschen und einen duplizierten Masken-Movieclip:
stop();
Stage.scaleMode = "noScale";

this.createEmptyMovieClip("rauschen", 1);
rauschen._x = maske._x;
rauschen._y = maske._y;

var aus = this.maske.duplicateMovieClip("aus", this.getNextHighestDepth());
aus._visible = false;

6. Nun benötigen wir ein BitmapData-Objekt und fügen es dem Platzhalter-Movieclip hinzu. Der Platzhalter-Movieclip wird wiederum vom Masken-Movieclip maskiert:
var bmp = new flash.display.BitmapData(maske._width, maske._height);
rauschen.attachBitmap(bmp, 1);
rauschen.setMask(maske);

7. Als nächstes erstellen wir die Funktion erstelleRauschen() um die Pixel kontinuierlich zu verändern. Dazu bedarf es einer onEnterFrame-Funktion und der noise() Methode:
function erstelleRauschen(){
this.onEnterFrame = function(){
bmp.noise(Math.floor(1000 * Math.random()), 0, 255, 1 | 2 | 4, true);
};
};
erstelleRauschen();

8. Zum Schluß geben wir noch dem Button die benötigte Funktionalität zum ein- und ausschalten des Fernsehers:
button.onPress = function(){
aus._visible = !aus._visible;
if(aus._visible == true){
delete this._parent.onEnterFrame;
}else{
this._parent.erstelleRauschen();
};
};

Wenn wir nun die Flash-Datei veröffentlichen sehen wir das bekannte TV-Rauschen.

Flash Tutorial: Textfeld Stylesheet (CSS) mit AS 3

Textfelder in Flash zu formatieren ging bis Flash MX nur über internes Actionscript. Seit der Version Flash MX 2004 konnte man aber auch das bekannte CSS nutzen, das als Bestandteil für normale Html-Seiten eine vernünftige Struktur zur Formatierung von Texten bietet. Heute zeigen wir euch deshalb, wie man mit AS3 und einer CSS-Datei ebenso Texte in Flash formatieren kann.

1. Dazu müssen wir als erstes eine CSS-Datei mit dem Namen style.css anlegen und folgende Formatierungen für eine Überschrift einfügen:
h1{
font-family: Arial, Helvetica, sans-serif; //Die Auswahl der Fonts
color: #999999; //Die Schriftfarbe
font-size: 20px; //Die Schriftgröße
}

2. Danach erstellen wir in Flash ein dynamisches Textfeld mit einigen Eigenschaften und positionieren dieses auf der Bühne. Zum Schluß fügen wir es dann der Anzeigeliste hinzu. Der gesamte AS3-Code kommt dabei ins erste Bild der Hauptzeitleiste:
var tf:TextField = new TextField();
tf.width = 250;
tf.height = 200;
tf.x = 250;
tf.y = 250;
tf.wordWrap = true;
tf.multiline = true;
addChild(tf);

3. Nun müssen wir das Stylesheet, also die style.css laden. Dies geschieht mit dem URLLoader. Mit dem Event-Listener Event.COMPLETE wird das Laden dann abgefangen und die Funktion pushCSS() aufgerufen:
var url:URLRequest = new URLRequest("style.css");
var loader:URLLoader = new URLLoader();

loader.addEventListener(Event.COMPLETE, pushCSS);
loader.load(url);

4. Zum Schluß erstellen wir in der Funktion pushCSS() ein neues Stylesheet-Objekt und lesen anschließend mit der Methode parseCSS() das CSS aus. Abschließend ist es wichtig, das wir erst das CSS dem Textfeld zuweisen und dann den Text hinzufügen:
function pushCSS(evt:Event){
var css:StyleSheet = new StyleSheet();
css.parseCSS(loader.data);
tf.styleSheet = css;
tf.htmlText = "<h1>Das ist die formatierte Überschrift</h1>";
}

Nun können beliebig viele Textfelder in Flash mit CSS formatiert werden und man erspart sich eine Menge Arbeit.

Flash Tutorial: 3D Objekt mit Papervision

Heute wollen wir euch zeigen wie man mit Papervision und ein wenig AS3, eine einfache 3D Plane in Flash erstellt. Dazu benötigen wir zuallererst die Klassen von Papervision. Diese kann man sich inklusive hilfreichen Faq`s zur Installation hier downloaden. Wenn möglich nutzt einen Versionskontrollmanager, auch Subversion Control genannt, wie etwa Tortoise SVN, um immer auf dem aktuellsten Stand zu bleiben. Nach der Installation können wir auch schon loslegen.

1. Als erstes erstellen wir eine AS-Datei mit Namen “PV3D.as”. Danach erstellen wir eine leere Flash-Datei, stellen die Bildrate auf 30 Bps und tragen in das Feld Dokumentklasse “PV3D” ein. Die beiden Files müssen im selben Ordner liegen.

2. Nun können wir auch schon die Klassen in die AS-Datei importieren. Diese werden zur Darstellung des 3D Objekts benötigt. Dazu einfach wie üblich in AS3 mit dem package Schlüsselwort beginnen:
package{
import flash.display.Sprite;
import flash.events.Event;
import org.papervision3d.view.Viewport3D;
import org.papervision3d.scenes.Scene3D;
import org.papervision3d.cameras.Camera3D;
import org.papervision3d.materials.ColorMaterial;
import org.papervision3d.objects.primitives.Plane;
import org.papervision3d.render.BasicRenderEngine;
}

2. Danach erweitern wir die Klasse Sprite um die öffentliche Klasse PV3D und initialisieren die benötigten Variablen:
package{
import flash.display.Sprite;
import flash.events.Event;
import org.papervision3d.view.Viewport3D;
import org.papervision3d.scenes.Scene3D;
import org.papervision3d.cameras.Camera3D;
import org.papervision3d.materials.ColorMaterial;
import org.papervision3d.objects.primitives.Plane;
import org.papervision3d.render.BasicRenderEngine;

public class PV3D extends Sprite {
private var viewport: Viewport3D;
private var scene: Scene3D;
private var camera: Camera3D;
private var material: ColorMaterial;
private var primitive: Plane;
private var renderer: BasicRenderEngine;
}
}

3. Nun zur eigentlich Funktion. Wir erstellen die öffentliche Methode PV3D und instanzieren ein neues Viewport-Objekt, das wir anschließend der Anzeigeliste hinzufügen. Als Parameter für new Viewport() übergeben wir width, height, scaleToStage und interactive:
public function PV3D():void {
viewport = new Viewport3D(550, 400, false, true);
addChild(viewport);
}

4. Es folgen weitere Instanzierungen von scene, camera, renderer, material, und primitive. Bei material setzen wir doubleSided auf true um die Farbe auf der Vorder,- und Rückseite anzuzeigen. Bei primitive erstellen wir eine neue Plane und weisen new Plane() die Parameter material, width, height, wSegments und hSegments zu. Die Segmente sind dabei die verwendeten Polygone, umso höher hier der Wert ist, umso höher aufgelöst ist das Objekt. Die Verwendung eines höheren Werts ist aber auch sehr performancelastig und man sollte sparsam damit umgehen. In unserem einfachen Beispiel reichen 3 Segmente horizontal und vertikal völlig aus. Zum Schluß wird primitive noch der scene hinzugefügt:
public function PV3D():void {
viewport = new Viewport3D(550, 400, false, true);
addChild(viewport);

scene = new Scene3D();
camera = new Camera3D();
renderer = new BasicRenderEngine();
material = new ColorMaterial(0x333333);
material.doubleSided = true;

primitive = new Plane(material, 200, 200, 3, 3);
scene.addChild(primitive);
}

5. Zu guter Letzt setzen wir noch einen ENTER_FRAME Event-Listener und weisen ihm die Methode onEnterFrame() zu. Hier lassen wir unsere Plane nun zur Laufzeit drehen und aktualisieren den renderer:
public function PV3D():void {
viewport = new Viewport3D(550, 400, false, true);
addChild(viewport);

scene = new Scene3D();
camera = new Camera3D();
renderer = new BasicRenderEngine();
material = new ColorMaterial(0x333333);
material.doubleSided = true;

primitive = new Plane(material, 200, 200, 3, 3);
scene.addChild(primitive);

addEventListener(Event.ENTER_FRAME, onEnterFrame);
function onEnterFrame(e:Event):void {
primitive.rotationY += 2;
renderer.renderScene(scene, camera, viewport);
}
}

Ganz zum Schluß speichern wir unsere AS-Datei und veröffentlichen die Flash-Datei. Als Ergebnis seht ihr eine sich permanent drehende 3D Plane, die mit wenig AS3 Code, Flash und Papervision erstellt wurde.

Hier nochmal der gesamte Code:
package{
import flash.display.Sprite;
import flash.events.Event;
import org.papervision3d.view.Viewport3D;
import org.papervision3d.scenes.Scene3D;
import org.papervision3d.cameras.Camera3D;
import org.papervision3d.materials.ColorMaterial;
import org.papervision3d.objects.primitives.Plane;
import org.papervision3d.render.BasicRenderEngine;

public class PV3D extends Sprite {
private var viewport: Viewport3D;
private var scene: Scene3D;
private var camera: Camera3D;
private var material: ColorMaterial;
private var primitive: Plane;
private var renderer: BasicRenderEngine;

public function PV3D():void {
viewport = new Viewport3D(550, 400, false, true);
addChild(viewport);

scene = new Scene3D();
camera = new Camera3D();
renderer = new BasicRenderEngine();
material = new ColorMaterial(0x333333);
material.doubleSided = true;

primitive = new Plane(material, 200, 200, 3, 3);
scene.addChild(primitive);

addEventListener(Event.ENTER_FRAME, onEnterFrame);
function onEnterFrame(e:Event):void {
primitive.rotationY += 2;
renderer.renderScene(scene, camera, viewport);
}
}
}
}

Flash Tutorial: Webcam mit AS3 steuern

Eine Webcam mit Flash zu steuern ist mit AS3 zum Kinderspiel geworden. In AS3 gibt es dafür die Klasse Camera im Paket flash.media. Wir zeigen euch hier eine einfache Anwendung um das Bild der Webcam in eurem Flashfilm darzustellen.

1. Zuerst müssen wir ein Camera Objekt erstellen und mit der Methode getCamera() die Webcam ansprechen:
var cam:Camera = Camera.getCamera();

2. Nun müssen wir prüfen ob eine Webcam vorhanden ist und wenn ja, diese an ein Video Objekt anhängen und der Anzeigeliste hinzufügen:
if(cam != null){
var video:Video = new Video();
video.attachCamera(cam);
video.x = 10;
video.y = 10;
addChild(video);
}

Das wars, mehr ist nicht nötig um mit Flash eine Webcam zu steuern. Wie ihr seht, ganz einfach! Wenn ihr nun noch das Bild mit anderen Usern austauschen wollt, benötigt ihr einen Mediaserver. Die Daten werden dann mit Netconnection und Netstream übertragen.

Flash Tutorial: Preloader mit AS 3

Möchte man mit Flash größere Daten laden, kommt es vor das bei langsamen Internetverbindungen, Animationen zwischendurch aussetzen oder überhaupt kein Bild zu sehen ist. Für solche Fälle gibt es in Flash sogenannte Preloader, die den Flash-Film komplett vorladen um ihn dann anschließend vollständig und ohne Ruckler abzuspielen. Angewendet werden diese Preloader schon seit es Flash gibt, wir wollen uns heute aber einem mit AS 3 programmierten Preloaders zuwenden.

Dazu benötigen wir 2 Textfelder und einen Balken-Movieclip, um den Ladefortschritt zum einem als Zahl und zum anderen grafisch darzustellen. Als erstes erstellen wir also 2 Textfelder, eins nennen wir total_txt und das andere loaded_txt, um einerseits die geladenen und die gesamten Kilobytes anzuzeigen. Danach erstellen wir einen Balken mit 100 px Breite und 30 px Höhe und nennen ihn bar_mc. Die Platzierung ist dabei euch überlassen.

Und nun zum Code:

1. Zuerst wird der Loader angelegt. Zum laden nehmt bitte eine möglichst große externe SWF, um später beim lokalen testen überhaupt etwas zu sehen:
var loader:Loader = new Loader();
var url:URLRequest = new URLRequest("test.swf");

2. Um den Ladefortschritt anzuzeigen, benötigen wir nun in Actionscript 3 ein Event ProgressEvent.PROGRESS. Dieses ist dem LoaderInfo-Objekt untergeordnet unter contentLoaderInfo. Das Event wird bei jedem Ladefortschritt ausgelöst und muß nicht beendet werden. Man spart sich damit die Aufrufe über ENTER_FRAME, so wie es in AS 2 oft gelöst wurde:
loader.contentLoaderInfo.addEventListener(ProgressEvent.PROGRESS, loading);

3. Danach brauchen wir das Ereignis Event.COMPLETE für das LoaderInfo-Objekt um abzufangen, wann der Ladevorgang fertig ist:
loader.contentLoaderInfo.addEventListener(Event.COMPLETE, ready);

4. Anschließend wird der Ladevorgang gestartet und der Anzeigeliste hinzugefügt:
loader.load(url);
addChild(loader);

5. Nun zu den Textfeldern. Hier werden nun die Bytes in Kilobytes umgewandelt, damit die Textfelder die geladenen, sowie die gesamten Kilobytes anzeigen:
function loading(evt:ProgressEvent){
loaded_txt.text = Math.round(evt.bytesLoaded / 1000);
total_txt.text = Math.round(evt.bytesTotal / 1000);
}

6. Für den Ladebalken benötigen wir nun noch eine Berechnung des Prozentwerts der geladenen Bytes im Verhältnis zu den gesamten Bytes. Dazu erweitern wir die Funktion loading() um 2 Codezeilen:
function loading(evt:ProgressEvent){
loaded_txt.text = Math.round(evt.bytesLoaded / 1000);
total_txt.text = Math.round(evt.bytesTotal / 1000);
var percent:int = 100 * evt.bytesLoaded / evt.bytesTotal;
bar_mc.width = percent;
}

7. Zum Schluß könnt ihr nun noch der Funktion ready() weitere Anweisungen hinzufügen. Oft wird hier zum nächsten Frame gesprungen oder der Abspielkopf wird auf play() gestellt. Was nun genau für Anweisungen dort hineinkommen ist euch überlassen:
function ready(evt:Event){
//Hier ist Platz für weitere Anweisungen;
}

Das wars auch schon. Nun könnt ihr ganz bequem mit Flash und Actionscript 3 einen Preloader bauen und eure Filme vorladen.

Flv mit Netstream und Netconnection laden und steuern

Flash Videos, kurz .flv, lassen sich heute recht einfach mit Flash laden und steuern. Dazu gibt es die FLVPlayback-Komponente, die eine komplette Steuerung beinhaltet und somit das laden und steuern der Flv`s zum Kinderspiel macht. Möchte man aber eigenes Actionscript schreiben um Flv`s zu laden und zu steuern, muß man auf die NetStream und NetConnection Klasse zurückgreifen. Dies ist schon mit AS 2 möglich gewesen, wir wenden uns aber heute dem Beispiel mit AS 3 zu.

1. Zuerst erstellen wir eine Instanz der NetConnection. Dabei muß kein anderer Server angegeben werden, da die Verbindung auf demselben Server erfolgt:
var nc:NetConnection = new NetConnection();
nc.connect(null);

2. Danach wird ein NetStream Objekt instanziert und NetConnection angefügt:
var ns:NetStream = new NetStream(nc);

3. Zum eigentlichen Abspielen und Laden der Datei benötigen wir die Methode play(Datei). Da aber der Film am Anfang angehalten werden soll muß die Flv anfangs auf pause() gesetzt werden. Darüber hinaus muß, damit das erste Bild angezeigt wird, die Abspielposition auf seek(0) gesetzt werden. Das ganze sieht dann so aus:
ns.play("video.flv");
ns.pause();
ns.seek(0);

4. Der Video-Stream ist nur verwendbar, wenn wir ihn an ein Video-Objekt anhängen, das mit attachNetStream(NetStream) geschieht. Nun erhält das Video noch die korrekten Höhen,- und Breitenmaße und wird dann unterhalb eines Anzeigeobjektcontainers hinzugefügt, der sich unterhalb einer Maske befindet und so einen Teil des Videos ausschneidet:
var video:Video = new Video();
video.attachNetStream(ns);
video.height = 320;
video.width = 240;
placeholderMc.addChild(video);

5. Um das Video zu steuern benötigen wir einen Play,- , Stop,- und Pausebutton.
In AS 3 müssen nun Event-Listener für die verschiedenen Button angelegt werden:
playBtn.addEventListener(MouseEvent.CLICK, videoPlay);
stopBtn.addEventListener(MouseEvent.CLICK, videoStop);
pauseBtn.addEventListener(MouseEvent.CLICK, videoPause);

6. Zum Schluß müssen noch die Funktionen für die Event-Listener geschrieben werden. Dabei ist zu beachten, daß das Abspielen nicht mit play() gestartet wird, sondern mit resume(), da wir den Stream schon ganz am Anfang abgespielt und angehalten haben:
function videoPlay(evt:MouseEvent){
ns.resume();
}

7. Das stoppen des Streams besteht aus pause(), sowie seek(0) um den Abspielkopf wieder an den Anfang zu setzen:
function videoStop(evt:MouseEvent){
ns.pause();
ns.seek(0);
}

8. Als letztes erfolgt noch das pausieren des Streams mit der Methode pause():
function videoPause(evt:MouseEvent){
ns.pause();
}

Diese Grundsteuerung läßt sich dann nach belieben erweitern, mit z.B. einer Positionsanzeige oder Vor,- und Zurückspulbutton, um einen voll funktionsfähigen Flash Videoplayer mit AS 3 zu bauen.

Flash Filter mit AS 3

Filter in Flash gibt es schon eine ganze Weile. Man kann sie entweder über den Eigenschafteninspektor einem Movieclip zuweisen, oder man programmiert sie in AS 2 oder AS 3. Wir wenden uns heute dem Beispiel eines in AS 3 programmierten Filters zu, da diese wesentlich flexibler zu steuern sind.

1. Zunächst erstellen wir ein BitmapData Objekt mit zwei Rechtecken:
var data:BitmapData = new BitmapData(200, 100, false, 0xFF0000);
var rect:Rectangle = new Rectangle(20, 20, 160, 60);
data.fillRect(rect, 0x00FFFF);

2. Um den Flash Filter anzuwenden, benötigt man 4 Informationen. Zum einen das BitmapData Objekt als Ursprung des Filters, einen Anfangspunkt, den Filter und ein Rechteck auf den der Filter angewendet wird:
var point:Point = new Point(20, 20);
var filter:BlurFilter = new BlurFilter();
data.applyFilter(data, rect, point, filter);

3. Zum Schluß muß das Bitmap noch zur Anzeigeliste hinzugefügt werden:
var bitmap:Bitmap = new Bitmap(data);
bitmap.x = 100;
bitmap.y = 100;
addChild(bitmap);

Mit diesem Basissetup lassen sich so verschiedene Flash Filter erstellen und modifizieren.

Externen Sound mit AS 3 laden und abspielen

Sounds müssen für Flash im MP3 Format vorliegen, um sie extern zu laden. Dazu benötigt man in AS 2, wie auch in AS 3 die Sound Klasse. Mit dieser ist es denkbar einfach einen Sound in Flash zu laden und abzuspielen. Die Klasse wurde in AS 3 aber um einige positive Veränderungen erweitert, auf die wir gleich zu sprechen kommen.

1. Zuerst müssen wir ein Sound Objekt erstellen:
var sound:Sound = new Sound();

2. Externen Sound laden:
sound.load(new URLRequest("sound.mp3"));
Die Methode load(URL), erwartet als Parameter eine Adresse, die in AS 3 immer konsistent mit einem URLRequest Objekt angegeben wird.

Alternativ kann man die Adresse auch vorab definieren:
var adress:URLRequest = new URLRequest("sound.mp3");

Eine andere und somit auch gleichzeitig die kürzeste Variante ist, die Adresse direkt beim Erstellen des Sound Objekts anzugeben:
var sound:Sound = new Sound(new URLRequest("sound.mp3"));

3. Sound steuern:
sound.play();

Neu in AS 3 ist, das man den Sound einem Soundkanal zuweisen muß um ihn weiter zu steuern. So ist jeder Sound der abgespielt wird, Teil eines Soundkanals und kann somit genauer gesteuert werden als noch in AS 2. Bei mehreren Sounds ist das äußerst sinnvoll. Der Soundkanal besitzt eine eigene Klasse, SoundChannel. Das dazugehörige Objekt muß aber nicht instanziert werden, sondern wird von sound.play() zurückgeliefert.

var channel:SoundChannel = sound.play();

Mit channel.stop() kann man dann den Sound auch wieder anhalten.

Animation mit dem Timer Objekt in AS 3

Animationen mit Flash zu erstellen ist nicht schwer. Man setzt einfach 2 Schlüsselbilder in die Zeitleiste, verschiebt den gewünschten Movieclip und schon hat man eine saubere Animation.

Wie aber sieht es aus, wenn man das ganze mit Actionscript erreichen will. Mit AS 2 hatte man da noch die Möglichkeit über setInterval() oder onEnterFrame(), eine gewünschte Funktion immer wiederkehrend aufzrufen. Das kann man natürlich auch noch mit AS 3. Neu in AS 3 ist aber die Klasse Timer. Diese erlaubt ebenfalls das wiederholte Aufrufen einer Funktion und ersetzt dank vieler neuen Features quasi setInterval(). Die Klasse selbst findest du unter flash.utils.

Und so gehts:

1. Timer Objekt erstellen:
var timer:Timer = new Timer(Zeitverzögerung, Wiederholungen);
Zeitverzögerung wird hierbei in Millisekunden angegeben und Wiederholungen bedeutet die maximale Anzahl an Wiederholungen bevor der Timer endet.

2. Event Listener erstellen, der die entsprechende Funktion aufruft:
timer.addEventListener(TimerEvent.TIMER, funktionsname);
TimerEvent kennt zwei Ereignisse: TIMER fängt jede Wiederholung ab, TIMER_COMPLETE wird einmal ausgeführt, wenn der Timer das Ende erreicht hat.

3.Timer starten:
timer.start();

Hier noch ein Beispiel anhand eines beliebigen Movieclips mit dem Instanznamen “mc”.

var timer:Timer = new Timer(20, 200);
timer.addEventListener(TimerEvent.TIMER, moving);
timer.start();

function moving(evt: TimerEvent){
mc.x += 3;
if(mc.x >= Stage.stageWidth){
timer.stop();
}
}

Darüber hinaus gibt es noch die Methode reset(), die den Timer zurücksetzt und currentCount, die ausliest bei wievielen Wiederholungen sich der Timer gerade befindet. running gibt true oder false zurück, je nachdem ob der Timer gerade läuft oder nicht.