halaszlo.blog.hu

Buli van!

Micsoda??? Uncsi? Szerintem is uncsi ez az egyszínű material. Szóval adjunk neki!
Ugorjunk egy nagyot és keressünk egy flv fájlt (Flash Video). Ha nincs kéznél, akkor itt van egy: Wes - Alena.
Ahhoz, hogy ezt materialként használjuk, meg kell tennünk pár dolgot.
Először is létre kell hoznunk egy Video objektumot.

public var vid:Video = new Video();

Ez az objektum úgynevezett netstream-eket tud lejátszani (én úgy fordítanám, hogy hálózati adatfolyam), ami annyit takar, hogy a hálózaton keresztül darabokban (folyamként) érkezik az adat az applikációnkhoz, nem kell letölteni az egészet ahhoz, hogy elkezdje játszani.
Hozzunk létre egy NetStreamet a deklarációk között, de ne rendeljünk hozzá new objektumot. Azt majd később tehetjük csak meg.

public var stream:NetStream;

Azért tudjuk ezt csak később létrehozni, mert a NetStream konstruktorának át kell adnunk egy NetConnection objektumot, amit előtte be kell majd állítanunk. De először is hozzunk létre egy NetConnection-t is.

public var con:NetConnection = new NetConnection();

Ok. Most akkor fordított sorrendben adjunk nekik értéket a Main függvényben:

con.connect(null);
stream = new NetStream(con);
vid.attachNetStream(stream);
stream.play("http://halaszlo.extra.hu/Wes - Alena.flv");

A connection-t null-ra állítjuk, ezzel azt mondjuk, hogy nem médiaszerverről szedjük az adatot, hanem lokális kapcsolatról van szó. Ez fontos lépés, mert különben nem működik.
A NetStream-nek átadjuk a connection-t, de csak azután, hogy null-ra állítottuk. Ezért nem tudjuk létrehozni a deklarációs részben a stream-et.
Ezután Video objektumhoz hozzárendeljük a streamet és a stream.play függvényével elindítjuk az flv-t.

Ha eddig eljutottunk, akkor akár már meg is nézhetjük a videot.

addChild(vid);

Ezután már csak hozzá kell rendelni a kockánk material-jához.
Ügyeljünk arra, hogy a deklarációs részben egyrészt a material VideoMaterial típusú legyen és ne hozzuk létre new-val az objektumot csak a Main függvényben, mivel a VideoMaterial konstruktorának meg kell adnunk a Video objektumunkat.

boxMat = new VideoMaterial(vid);

Ugyanígy az appearance-t is csak ezután hozzuk létre:

boxApp = new Appearance (boxMat);
box.appearance = boxApp;

Beleraktam még egy függvényt és ennek aktiválását arra az esetre, ha valakit zavarna a video, egy klikkel meg lehet állítani és ugyanígy újraindítani. Az esemény (klikk) figyelésére a MouseEvent.CLICK esemény "lehallgatását" használom.

addEventListener(MouseEvent.CLICK, onClick);

Ne felejtsük el az import részbe berakni előtte a MouseEvent beimportálását. A klikk esemény kezelésére pedig az onClick függvény fog meghívódni:

public function onClick(e:Event):void
{
      if (streamStat == 1)
      {
            stream.pause();
            streamStat = 0;
      }
      else
      {
            stream.resume();
            streamStat = 1;
      }
}

A függvényben van egy elégazás (if), ami vizsgálja, hogy a video áll, vagy megy, és ennek megfelelően a klikk hatására elindítja, vagy megállítja azt. Ennek az állapotnak a vizsgálatára felvettem egy stramStat nevű numerikus változót, amit 1-re állítok, ha megy a video és 0-ra ha megállt.

A teljes program így alakult:
(kiszedtem a material attributumokat és a forgást is egy kicsit megváltoztattam)
 

package
{
    import flash.display.Sprite;
    import flash.events.Event;
    import flash.events.MouseEvent;
    import caurina.transitions.Tweener;
    import flash.media.Video;
    import flash.net.NetStream;
    import flash.net.NetConnection;
    import sandy.core.Scene3D;
    import sandy.core.scenegraph.*;
    import sandy.primitive.*;
    import sandy.materials.*;
    import sandy.materials.attributes.*;
  
    public class Main extends Sprite
    {
        public var vid:Video = new Video();
        public var stream:NetStream;
        public var con:NetConnection = new NetConnection();
       
        public var box:Box = new Box("box",100,100,100);
        public var camera3D:Camera3D = new Camera3D(800, 600);
        public var g:Group = new Group("g");
        public var scene:Scene3D;
        public var boxMat:VideoMaterial;
        public var boxApp:Appearance;
        public var streamStat:Number = 1;

        public function Main():void
        {
            addEventListener(Event.ENTER_FRAME,onEnterFrame);
            addEventListener(MouseEvent.CLICK, onClick);
           
            con.connect(null);
            stream = new NetStream(con);
            vid.attachNetStream(stream);
            stream.play("http://halaszlo.extra.hu/Wes - Alena.flv");
            addChild(vid);
           
            scene = new Scene3D("scene", this, camera3D, g);
            g.addChild(box);
            boxMat = new VideoMaterial(vid);
            boxApp = new Appearance (boxMat);
            box.appearance = boxApp;

        }
        public function onEnterFrame(e:Event):void
        {
            box.rotateX = box.rotateX + 1;
            box.rotateY = box.rotateY + 2;
            scene.render();
        }
        public function onClick(e:Event):void
        {
            if (streamStat == 1)
            {
                  stream.pause();
                  streamStat = 0;
            }
            else
            {
                  stream.resume();
                  streamStat = 1; 
            }
       }
    }
}
 

Megállításhoz kattints a kockára.

Fény, anyag, ilyesmi...

Most, hogy már mozog a kockánk. el kellene látni némi anyaggal. Ez a drótháló elég sivár.
FlashSandy-ben azt két lépésben tudjuk megtenni: szükségünk lesz egy appearance-ra (kinézet) és egy material-ra (anyag).

Először is az import szekciót ki kell egészítenünk 2 sorral:
import sandy.materials.*;
import sandy.materials.attributes.*;

Egy sima, egyszínű anyagot fogunk hozzárendelni a kockához, de ahhoz, hogy valóba 3D hatása legyen meg kell tennünk egy-két lépést. igazság szerint szerintem ezt a részt egy kicsit elbonyolították a 3. verziójában a Sandy-nek, de gondolom a maximális paraméterezhetőség érdekében tették.
A lényeg, hogy létre kell hoznunk egy materialt:

public var boxMat:Material = new ColorMaterial(0xff0000);

A ColorMatieral az egy egyszínű anyag, aminek konstruktorában meg kell adnunk az anyag színét.

A szín flashben 0x -el kezdődik, ami azt jelenti hogy hexadecimális számot adunk meg. Ezután következik a piros, a zöld és a kék színösszetevők megadása 2-2-2 karakterrel. Minden színösszetevő 00-tól ff-ig terjedhet. Segítségül itt egy táblázat a színekre.

Sajnos a materialt nem tudjuk közvetlenül hozzárendelni a tárgyhoz, ezért létre kell hozni egy appearance-t is (kinézet).

public var boxApp:Appearance = new Appearance (boxMat);

Ennek kell paraméterként átadnunk a materialt és ezt már hozzá lehet rendelni a box appearance tulajdonságához. Ezt valahol a Main függvényben megtehetjük a következő sorral:

box.appearance = boxApp;

Ezután már működik is a piros, forgó kockánk, csak mint korábban említettem fényhatás nélkül elég "egysíkú".

Amit most mutatok, azzal jelentősen lerövidíthetjük a programjainkat. Amikor paraméterként egy függvénynek vagy egy változónak nem egy értéket, hanem egy másik objektumot kell átadnunk, mindig előtte létre kell hoznunk az objektumot és utána adhatjuk át. Azonban ezt elvégezhetjük egy lépésben is. Tehát létrehozzuk az objektumot és átadjuk paraméterként. Sőt ezeket egymásba is ágyazhatjuk, így egy sorban sok-sok lépést elvégezhetünk, a programunk áttekinthetőbb lesz és nem hozunk létre felesleges objektumokat. Hátránya, hogy az így létrehozott objektumok csak akkor és ott használhatók, amikor és ahol létrehozzuk és átadjuk őket paraméterként.

Most a materialunknak kellene az attributum paraméterének átadni egy MaterialAttributes objektumot, amit előtte létre kell hoznunk. Viszont a MaterialAttributes-nak paraméterként át kellen adnunk egy LightAttributes objektumot, amit előtte szintén létre kellene hoznunk.
Mi most ezt egy lépésben megoldjuk. Így:

boxMat.attributes = new MaterialAttributes(new LightAttributes(true, 0.1));

A MaterialAttributes egy olyan tömb, aminek az egyes elemei valamilyen attributumot (tulajdonság) írnak le. (pl fény, vonalvastagság stb). Itt mi a "fény" attributumát adtuk cssak meg, aminek első paramétere az, hogy fényes legyen-e az anyag vagy sem, a második paramétere pedig a fény "erősége" a felületen (ambien light). Értéke 0 és 1 között kell, hogy legyen.

Ezen kívül egy feladatunk van, "be kell kapcsolnunk" a materialnak azt a tulajdonságát, hogy "ragáljon" a fényre:

boxMat.lightingEnable = true;

A teljes programunk így alakult:

package
{
    import flash.display.Sprite;
    import flash.events.Event;
    import caurina.transitions.Tweener;
    import sandy.core.Scene3D;
    import sandy.core.scenegraph.*;
    import sandy.primitive.*;
    import sandy.materials.*;
    import sandy.materials.attributes.*;
   
    public class Main extends Sprite
    {
        public var box:Box = new Box("box",50,50,50);
        public var camera3D:Camera3D = new Camera3D(800, 600);
        public var g:Group = new Group("g");
        public var scene:Scene3D;
        public var boxMat:Material = new ColorMaterial(0xff0000);
        public var boxApp:Appearance = new Appearance (boxMat);

        public function Main():void
        {
            addEventListener(Event.ENTER_FRAME,onEnterFrame);
            scene = new Scene3D("scene", this, camera3D, g);
            g.addChild(box);
            boxMat.attributes = new MaterialAttributes(new LightAttributes(true, 0.1));
            boxMat.lightingEnable = true;
            box.appearance = boxApp;
            box.rotateX = 30;
            scene.render();
        }
        public function onEnterFrame(e:Event):void
        {
            box.rotateX = box.rotateX + 1;
            scene.render();
        }
    }
}
 

Mozgás, mozgás, mozgás!

Folytassuk a 3D-ben való kalandozásunkat. A kockánk jelenleg nem túl látványos. Nincs anyaga és miután csak az egyik oldalát mutatja felénk, egy négyzetet látunk. Éppen ezért forgassuk meg.
A forgatás többféleképpen történhet. Az egyik és legegyszerűbb megoldás az objektumok rotateX, rotateY, rotateZ tulajdonsága és értelemszerűen az X, Y és Z tengelyek körüli forgatás mértékét jelentik. Ezt fokokban kell megadni.

Próbáljuk ki. Tegyük be a következő sort a scene.render() elé. Előbb elforgatjuk a kockát és utána renderelünk. Ha fordítva tennénk, akkor nem látnánk változást.

box.rotateX = 30;

Nagyon pici ez a kocka. Kicsit nagyítsunk rajta. A létrehozásakor használt konstruktor paramétereket bővítsük a következőképpen:

public var box:Box = new Box("box",50,50,50);

Ezzel az x,y,z irányú hosszúságait adhatjuk meg. (gyakorlatilag az a, b, c oldaléleket).
Így már egy kicsit jobb a kép.

Viszont még mindig nem mozog ez a kocka. Ahhoz, hogy "realtime" mozgást tudjunk csinálni, szükségünk lesz egy függvényre, ami egymás után sokszor meghívódik. Ezek az úgynevezett Frame-ek. Egy másodperc alatt alapesetben 30 Frame fut le, de ezt lehet változtatni a FlashDevelop Project - Properties - Output fül alatt. El kell készítenünk egy függvényt, ami minden frame lefutásakor meghívódik, és aktiválni is kell azt.
A függvényt a Main függvény után helyezzük el. (Vigyázat Ne az osztály után...)

public function onEnterFrame(e:Event):void
{
           
}

Az e:Event azt jelenti, hogy ennek a függvénynek egy paramétere van, ami Event típusú. Ezt a paramétert meghíváskor fogja megkapni a függvény, de mivel ezt a függvényt nem mi hívjuk meg, hanem a rendszer, ezért egyelőre nem kell vele foglalkoznunk. Később viszont sok hasznos infót tudhatunk meg belőle, főleg arra vonatkozóan, hogy milyen "esemény" váltotta ki az eljárásunk meghívását.
Tehát ez a függvény egy esemény bekövetkeztekor fog lefutni, mégpedig akkor, amikor a program belép a következő frame-be.

Azt szeretnénk, ha a frame-ek váltásakor a kocka fordulna egy picit. Ezért az onEnterFram eljárásban fordítunk rajta egy picit. És minden egyes pici elmozdulás után újrarendereljük a scene-t.

public function onEnterFrame(e:Event):void
{
      box.rotateX = box.rotateX + 1;
      scene.render();
}

Ha most lefuttatjuk a programunkat, akkor nem történik semmi, mivel hiányzik egy fontos lépés. aktiválnunk kell az eseménykezelő eljárást. Valahol a Main függményben el kell helyezni a következő sort:

addEventListener(Event.ENTER_FRAME,onEnterFrame);

Ezt báhova tehetjük a Main függvényen belül de érdemes vag az elesére vagy a végére rakni, hogy könnyem megtaláljuk. Ugyanis később lehet belőle több is.
Szóval ezzell a sorral mondjuk meg, hogy az ENTER_FRAME esemény bekövetkeztekor melyik függvény fusson le. Az ENTER_FRAME esemény pedig másodpercenként 30-szor lefut (és most már a függvényünk is...)

 Ateljes programunk pedig így alakult:

package
{
    import flash.display.Sprite;
    import flash.events.Event;
    import caurina.transitions.Tweener;
    import sandy.core.Scene3D;
    import sandy.core.scenegraph.*;
    import sandy.primitive.*;
   
    public class Main extends Sprite
    {
        public var box:Box = new Box("box",50,50,50);
        public var camera3D:Camera3D = new Camera3D(800, 600);
        public var g:Group = new Group("g");
        public var scene:Scene3D;
       
        public function Main():void
        {
            addEventListener(Event.ENTER_FRAME,onEnterFrame);
            scene = new Scene3D("scene", this, camera3D, g);
            g.addChild(box);
            box.rotateX = 30;
            scene.render();
        }
        public function onEnterFrame(e:Event):void
        {
            box.rotateX = box.rotateX + 1;
            scene.render();
        }
    }
}

Irány a 3. dimenzió

És máris szeretnék rátérni arra, ami az egész ingyenes fejlesztésnek értelmet ad.
Az Adobe fejlesztőeszközeinek van egy nagy hátránya. Hiányoznak belőle a 3D-s lehetőségek. Mondjuk a CS4-ben már kezd valami kibontakozni, de ez még korántsem tavasz...

A FlashSandy egy ingyenes, "nyílt forráskódú" Flash 3D fejlesztő osztály csomag. Én azért ezt használom, mert könnyen kezelhető és logikus felépítésű.
Kezdjük is el:
Innen letöltve, tömörítsük ki, majd a FlashDevelopment-ben a Project - Properties - Classpaths - Add Classpath ...  menüpontok után keressük meg és válasszuk ki a kitömörített sandy könyvtárat (jelenleg sandy_3_0_2_src). A Project ablak így változik:

Egy minimális FlashSandy 3D programhoz szükségünk lesz a következő osztályok importálására:
import sandy.core.Scene3D;
import sandy.core.scenegraph.*;
import sandy.primitive.*;

Az első, a "Scene" lesz az a színpad, ahol a 3D összeállítás "szereplőit" felállítjuk. Szükségünk lesz egy kamerára, ami "nézi" a szereplőket, egy képernyőre, amire kivetítjük és legalább egy szereplőre aki játszik. A Scene3D ennek ad teret és ezeket mind összefogja: a kamerát, a képernyőt, és a szereplőket.

Fordított sorrendben fogunk dolgozni. Először létrehozunk egy szereplőt. Ez legyen egy "doboz". Más szóval egy kocka. Ez a primitive csomagban található és azért úgy hívjuk meg, hogy primitive.*, hogy a többi szereplőt is könnyen elő tudjuk hívni később. Szóval létre hozzuk a boxot:

public var box:Box = new Box("box");

Ezt a Main Function elé teszem, és azért public előtaggal, hogy amennyiben több eljárást írunk, mindegyikből látható és kezelhető legyen.
Létrehozok egy kamerát, ami felveszi Mr. Box műsorát:

public var camera3D:Camera3D = new Camera3D(800, 600);

A kamera konstruktorának (ez az az eljárás, ami a kamera létrehozásakor lefut és kezdőértékekekt ad neki) megadjuk a kamera felbontását. Ezt érdemes akkorának venni, mint a projektunk felbontása, illetve akkorára, mint amilyen felületre majd ki fogjuk vetíteni a képet (ez esetünkben a Flash projektünknek otthont adó Main Sprite).

Szükségünk van egy "csoportra", ami a színtársulatot összefogja. Ez lesz a helyi színjátszó kör. :)

public var g:Group = new Group("g");

És végül szükségünk lesz egy színpadra, ahol helyet adunk a játékra.

public var scene:Scene3D;

Ezt csak deklaráljuk, de létre még nem hozzuk, mivel ennek a konstruktorának meg kell adnunk paraméterként a képernyőt, amire "kivetítjük" majd a képet és a programunknak ebben a fázisában (még a Main konstruktor lefutása előtt" még nem  áll készen. Éppen ezért, ezt csak a main konstruktoron belül tesszük meg, így:

public function Main():void
{
        scene = new Scene3D("scene", this, camera3D, g);

...

Tehát, sorrendben, a Scene3D konstruktorának a paraméterei:
- a neve
- a második paraméter az a Sprite, amire ki akarjuk vetíteni a 3D képet. Mivel mi a projektünk Main Sprite-ját fogjuk erre használni, elég úgy hivatkozni rá, hogy this.
- a harmadik paraméter maga a kamera
-  a negyedik pedig a színjátszó csoport, ami összefogja a szereplőket. Ez jelenleg még üres, de mindjárt hozzárendeljük Mr. Box-ot. Így:

g.addChild(box);

Ezzel adjuk hozzá a szereplőket a csoporthoz. Casting. :)

És felvétel indul!

scene.render();

Ezzer rendereljük a kamera képét a vászonra.

A teljes program így néz ki:

package
{
    import flash.display.Sprite;
    import flash.events.Event;
    import caurina.transitions.Tweener;
    import sandy.core.Scene3D;
    import sandy.core.scenegraph.*;
    import sandy.primitive.*;
   
    public class Main extends Sprite
    {
        public var box:Box = new Box("box");
        public var camera3D:Camera3D = new Camera3D(800, 600);
        public var g:Group = new Group("g");
        public var scene:Scene3D;
       
        public function Main():void
        {
            scene = new Scene3D("scene", this, camera3D, g);
            g.addChild(box);
            scene.render();
        }
    }
}

Ha minden jól ment, valami ilyesmit látunk:

Tween könnyedén - Tweener

Szeretném a szokásos actionscript komponensek és metódusok ismertetésétől eltérően inkább az ingyen fejlesztést elősegítő megoldásokat kiemelni. Ezek közül a legfontosabb a Tweener "osztály csomag". Ezzel tudjuk mozgatni a különböző objektumokat, és tudjuk változtatni a különböző paramétereket (például szín, átlátszóság, méret, stb), úgy hogy átmenet is van. Ezek az átmenetek lehetnek lineárisak, gyorsulóak, lassulóak, pattogók és még rengeteg féle mód van a paraméterek változtatására.

Amint letöltjük a Tweener csomagot (tweener_1_31_74_as3.zip), tömörítsük ki egy könyvtárba. Fontos, hogy hozzunk létre egy külön könyvtárat, amibe a zip fájl tartalmát pakoljuk (pl. Tweener_1_31\caurina\transitions\..). Később erre könyvtárra kell majd hivatkoznunk. A legutóbbi programot ott fejeztem be, hogy rajzoltunk egy négyzetet.
 

FlashDevelop-ban külső osztályokat a Project - Properties menü - Classpaths fül - Add Claspath gombjával adhatunk meg. A Browser ablakban keressük meg és válasszuk ki azt a könyvtárt, amit létrehoztunk (ami tartalmazza a caurina alkönyvtárat).
Az oldalsó Project ablak így módosul:





 

Így már meg is tudjuk hívni a Tweener osztályt az import részben:

import caurina.transitions.Tweener;

Elég beírni azt, hogy import Tweener és a FlashDevelop megkeresi az útvonalat. Viva FlashDevelop!
Ezután használhatjuk a Tweener osztályt a Main függvényben egy új "átmenet" létrehozásához. Ehhez a Tweener osztály addTween metóduát kell alkalmaznunk:

Tweener.addTween(this, { x:100, time:1, transition:"linear" } );

Az addTween-nek két paramétere van: az első az objektum neve, amelyet szeretnénk mozgatni színezni, stb.
A második paramáter pedig egy kapcsoszárójelek között felsorolt paraméterlista. Itt mondhatjuk meg, hogy az objektum paraméterét mire, mennyi idő alatt (másodpercben mérve) és milyen "stalusban" szeretnénk módosítani.
A teljes programunk így változik:

package
{
    import flash.display.Sprite;
    import flash.events.Event;
    import caurina.transitions.Tweener;

    public class Main extends Sprite
    {
        public function Main():void
        {
               this.graphics.lineStyle(1);
               this.graphics.drawRect(10, 10, 100, 100);
               Tweener.addTween(this, { x:100, time:1, transition:"linear" } );
        }
    }
}

Próbáljuk ki a "linear" helyett az "easeOutBounce" típust.
Itt találhatunk ismertetőt a különböző átmenet típusokhoz: Tweener Transition Types.

Jó szórakozást!

Kis napi rajozlás

ActionScript programozással folytatom a tegnapi "leckét".
Töröljük ki a felesleges sorokat a FlashDevelop által létrehozott alap programból.
Töröljük ki az init eljárást, a Main függvény belét és az author-ra vonatkozó sorokat.
Így már szerintem sokkal egyszerübb Default programvázat kapunk:

package
{
    import flash.display.Sprite;
    import flash.events.Event;
   
    public class Main extends Sprite
    {
        public function Main():void
        {
           
        }
    }
}

Aki Adobe Flash-hez van szokva, annak furcsa lehet a Sprite komponens. Ez gyakorlatilag ugyanaz, mint a MovieClip csak a Frame rész ki van hagyva belőle, így elvileg egyszerűbb és ezáltal kisebb is. De a MovieClip ugyanúgy megtatlálható itt is.
Fontos, hogy az .as fájlnak és az osztálynak (class) ugyanaz legyen a neve. (Jelen esetben Main). Szóval ha megváltoztatjuk valami.as-re akkor az osztály definicióját is át kell írni class valami-re.
Az osztály definición belül pedig az osztály nevével megegyező nevű függvény az úgynevezett konstruktor, ami automatikusan lefut. Egyelőre még üres, de ha írunk bele valamit, akkor az csak akkor fut le, ha ugyanaz a neve, mint az osztálynak.
Javaslom, hogy hagyjunk mindent Main néven.

Jó lenne, ha csinálna is valamit ez a program. Írjuk be a Main függvény belsejébe a következő 2 sort:
this.graphics.lineStyle(1);
this.graphics.drawRect(10, 10, 100, 100);

A teljes program így alakul:

package
{
    import flash.display.Sprite;
    import flash.events.Event;
   
    public class Main extends Sprite
    {
        public function Main():void
        {
               this.graphics.lineStyle(1);
               this.graphics.drawRect(10, 10, 100, 100);
        }
    }
}

Jaj de szép négyzetet rajzoltunk. Az első sor határozza meg, hogy milyen vonallal rajzoljunk (1 pixel vastagságú), a második pedig azt, hogy mit (az x=10, y=10 koordinátáktól kezdve 100 széles és 100 magas négyzetet).

Hát, ennyi fér bele mára...

Flash Develop - New Project

Folytatom a  FlashDevelop -al kapcsolatos eszmefuttatásokat.
Telepítés után az első megnyitáskor új projekt létrehozásához kattintsunk a 'New Project'-re.


 

Ekkor kapunk egy új ablakot, ami valahogy így néz ki:

Ez egyébként változó (arra, hogy mitől, még nem jöttem rá), mindenesetre vagy az AS3 projectet, vagy az AS3 csoport alatt a Default Projectet kellene választani.
A Browse-al válasszuk ki projekt helyét (Location) és érdemes kipipálni a 'Create directory...'-t is, mert így létrehoz a projektünknek egy új könyvtárat, olyan névvel, amit a 'Name' mezőben megadunk.
Ha minden kész, kattintsunk az OK-ra.
A főképernyőn nem változott semmi, de jobb oldalt a 'Project' ablakban megjelent egy fa szerkezet. Nyissuk le az scr könyvtárat.

 

Találunk itt egy Main.as fájlt.  Kattintsunk rá kétszer. Ekkor a főképernyőn megnyitja szerkesztésre:

package
{
    import flash.display.Sprite;
    import flash.events.Event;
    /**
     * ...
     * @author ...
     */
    public class Main extends Sprite
    {
        public function Main():void
        {
            if (stage) init();
            else addEventListener(Event.ADDED_TO_STAGE, init);
        }
        private function init(e:Event = null):void
        {
            removeEventListener(Event.ADDED_TO_STAGE, init);
            // entry point
        }
    }
}

Ennek a futtatásához azonban még szükségünk lehet egy FlexSDK-hoz. Ez a korábbi verziókban mintha nem lett volna, de most valamiért már szükséges.
Valójában a Flex (annak aki még nem hallott róla), az Adobe egy ingyenes és nyílt forráskódú fejlesztőeszköze. Letöltése után csomagoljuk ki és másoljuk az eredményt bárhova.
Ha futtatni szeretnénk az új scriptünket a Ctrl+Enter megnyomásával, akkor kérheti, hogy az AS3 környezetet állítsuk be:

 

Nyomjunk Ok-t és a következő ablakkon keressük meg a FlexSDK location sort:

Itt keressük meg, vagy írjuk be annak a könyvtárnak az útvonalát, ahova a FlexSDK-t kitömörítettük. Ha megvan, akkor zárjuk be ezt az ablakot és nyomjuk meg újra a Ctrl+Entert.

Ha minden jól ment, most már befordítja és meg is nyitja a scriptünket, ami egy üres ablak lesz, úgyanis az új scriptünk (annak ellenére, hogy elég sok sorból áll) nem csinál semmit.
Folytatása már az Flash ActionScript résszel folytatódik.

Sokan nem tudják, hogy flash programokat nem csak illegálisan lehet ingyenesen készíteni.
A legjobb megoldás erre a FlashDevelop nevű program.
Az Adobe Flash-el ellentétben ugyan nincs benne Frame szerkesztő, viszont ami az ActionScript szerkesztést illeti, az fényévekre van az Adobe programjától. Nem is értem, hogy az Adobe hogy lehet ilyen igénytelen, hogy még a CS4-ben is ennyire elhanyagolja a kódszerkesztést.
Szóval ez a fejlesztőeszköz inkább programozóknak jó (sőt, csak nekik), viszont aki ért hozzá az tud vele swf fájlokat készíteni, ami utána már ugyanúgy használható a weblapokon.

Telepítés után lehet egy új projektet kezdeni és ha a Default Projektet választjuk (amiből több is van, attól függően, hogy as2 vagy as3, esetleg Flex programot szeretnénk írni), akkor kapunk egy alap scriptet, ami máris futtatható (Ctrl+Enter, ugyanúgy, mint az Adobe esetén).
Oldalt, a Project ablakban megjelenik egy könyvtárszerkezet, ahol az src könyvtárban lévő Main.as scriptet megnyitva máris módosíthatjuk az újdonsült programunkat. Az első futtatás után pedig a kész swf fájlt a bin könyvtárban találjuk.

Jó szórakozást!