Share
Under denna handledning kommer vi ytterligare att utvidga kommandorammen från första delen. Vi skapar en ram för scenhantering, med lättförståelig och underhållbar kod.
Låt oss ta en titt på det slutliga resultatet vi ska arbeta för:
Ett rimligt sätt att bryta en komplett Flash-applikation i mindre bitar är att hantera den som separata scener. Flash IDE gör att du kan utföra scenhantering utan att skriva någon kod, men vi kommer att närma oss saker helt annorlunda. Vi ska skapa vår egen scenhanteringsram.
I våra scenhanteringsramar betraktar vi scener som de minsta byggstenarna för en komplett Flash-applikation. Varje scen består av en intro kommando och an outro kommando. Ett intro-kommando initierar allt du behöver för en scen, till exempel att lägga till en logotyp i visningslistan på din behållare. Ett outro-kommando gör det motsatta, till exempel att ta bort logotypen från behållarens sprit. Du kan se övergång från en scen till en annan som Outro-kommandot på den första scenen följt av intro-kommandot för den andra. På detta sätt kan vi sätta scener tillsammans och hantera deras övergångar mycket enkelt.
Ta en titt på den här siffran. En scen är precis som en bit av ett pussel; den vänstra änden representerar intro-kommandot, och den högra änden är kommandot outro.
Att genomföra en övergång från scen A till scen B är precis som att koppla samman de två delarna. Outro-kommandot för scen A körs först, intro-kommandot för scen B körs därefter, sedan är scenövergången klar.
Det är i grunden det exakta samma konceptet att utföra en övergång från scen A till scen C. Vi måste bara lägga pusselbitar A och C i stället för A och B.
Innan vi börjar bygga ramverket för scenhantering, låt oss först skapa några fler kommandokurser som senare kommer att användas i denna handledning. Du kan bara fokusera på de överförda exekvera () metoderna för följande kommandoklasser, vilket är den viktigaste delen av dessa klasser.
Utan tvekan är GreenSock Tweening Platform en av de bästa öppna källkodsramarna där ute. Scenövergångar innebär vanligtvis massor av tweenings, och GreenSock Tweening Platform har alltid varit mitt första val när det gäller att skapa tweens. Vi kommer att inkapsla denna ram i kommandoklasser för att integrera den med vår kommandoram. Ladda ner TweenMax-biblioteket och installera det.
Vi använder metoderna till () och från () från klassen TweenMax. TweenMax-klassen ger ett sätt att hantera slutförandet av en tween genom att åberopa en funktion som hänvisas till av den valfria "onComplete" -egenskapen i parametern "vars". Vi tilldelar kommandot fullständiga () -metoden till den här egenskapen, så hela () -metoden påkallas när intervallet är gjort. Nedan är koden för kommandon som inkapslar dessa två metoder. Skapa en ny katalog som heter "greensock" i katalogen "kommandon" du skapade i den första delen av denna handledning och spara dessa klasser som TweenMaxTo.as respektive TweenMaxFrom.as.
paketkommandon.greensock import com.greensock.TweenMax; importera kommandon.kommando; // detta kommando inkapslar TweenMax.to () -metoden offentlig klass TweenMaxTo utökar kommandot public var target: Object; allmän varaktighet: nummer; public var vars: Object; allmän funktion TweenMaxTo (mål: Object, duration: Number, vars: Object) this.target = target; this.duration = duration; this.vars = vars; åsidosätta skyddad funktion exekvera (): void // berätta TweenMax för att anropa kommandot fullständiga () -metoden när tweening är klar vars.onComplete = complete; TweenMax.to (mål, duration, vars);
paketkommandon.greensock import com.greensock.TweenMax; importera kommandon.kommando; // detta kommando inkapslar metoden TweenMax.from () offentlig klass TweenMaxFrom utökar kommandot public var target: Object; allmän varaktighet: nummer; public var vars: Object; offentlig funktion TweenMaxFrom (mål: Objekt, längd: Nummer, vars: Objekt) this.target = target; this.duration = duration; this.vars = vars; åsidosätta skyddad funktion exekvera (): void // berätta TweenMax för att anropa kommandot fullständiga () -metoden när tweening är klar vars.onComplete = complete; TweenMax.from (mål, duration, vars);
(Var noga med att läsa igenom min introduktion till kommandon om du behöver uppdatera ditt minne.)
TweenMaxTo kommer att mellanliggande objektet från dess nuvarande position (eller oskärpa, eller alfa, eller ...) till den nya positionen (etc) som du anger med vars-objektet. TweenMaxFrom gör motsatsen.
Om du är bekant med GreenSock Tweening Platform, kanske du också vill inkapsla klasserna TweenLite och TweenNano för att passa dina behov.
Som tidigare nämnts kan intro och outro av en scen mycket sannolikt innebära att man lägger till visningsobjekt i en visningsobjektbehållare och tar bort objekten från behållaren. Så här låt oss inkapslera addChild () och removeChild () metoderna till kommandon.
paketkommandon.display import commands.Command; importera flash.display.DisplayObject; importera flash.display.DisplayObjectContainer; // Detta kommando inkapslar addChild () -metoden offentlig klass AddChild utökar kommandot public var container: DisplayObjectContainer; public var displayObject: DisplayObject public function AddChild (behållare: DisplayObjectContainer, displayObject: DisplayObject) this.container = container; this.displayObject = displayObject; åsidosätta skyddad funktion exekvera (): void container.addChild (displayObject); komplett();
paketkommandon.display import commands.Command; importera flash.display.DisplayObject; importera flash.display.DisplayObjectContainer; // Detta kommando inkapslar methoden removeChild () public class RemoveChild utökar kommandot public var container: DisplayObjectContainer; public var displayObject: DisplayObject public function RemoveChild (behållare: DisplayObjectContainer, displayObject: DisplayObject) this.container = container; this.displayObject = displayObject; åsidosätta skyddad funktion exekvera (): void container.removeChild (displayObject); komplett();
Vi använder också kommandon för att hantera tillägg och borttagning av händelselyttare, så låt oss inkapslera addEventListener () och removeEventListener () metoder.
paketkommandon.events import commands.Command; importera flash.events.IEventDispatcher; // detta kommando inkapslar addEventListener () -metoden offentlig klass AddEventListener utökar kommandot public var dispatcher: IEventDispatcher; offentlig var typ: String; allmän var lyssnare: Funktion; offentlig funktion AddEventListener (avsändare: IEventDispatcher, typ: String, lyssnare: Funktion) this.dispatcher = dispatcher; this.type = type; this.listener = lyssnare; åsidosätta skyddad funktion exekvera (): void dispatcher.addEventListener (typ, lyssnare); komplett();
paketkommandon.events import commands.Command; importera flash.events.IEventDispatcher; // detta kommando inkapslar methoden removeEventListener () public class RemoveEventListener utökar kommandot public var dispatcher: IEventDispatcher; offentlig var typ: String; allmän var lyssnare: Funktion; offentlig funktion RemoveEventListener (avsändare: IEventDispatcher, typ: String, lyssnare: Funktion) this.dispatcher = dispatcher; this.type = type; this.listener = lyssnare; åsidosätta skyddad funktion exekvera (): void dispatcher.removeEventListener (typ, lyssnare); komplett();
Slutligen behöver vi några verktygskommandon för att göra det enklare. Kommandot SetProperties sätter ett objekts egenskaper från ett annat objekts fastighetsvärden:
paketkommandon.utils import commands.Command; // detta kommando sätter ett objekts egenskaper på ett snabbt och bekvämt sätt public class SetProperties utökar Command public var target: Object; offentliga varegenskaper: Objekt; allmän funktion SetProperties (mål: Object, properties: Object) this.target = target; this.properties = egenskaper; åsidosätta skyddad funktion exekvera (): void for (var-tangent: String i egenskaper) target [key] = properties [key]; komplett ();
Vi kan använda den så här:
var setProperties: SetProperties = new SetProperties (mål, x: 100, y: 230);
... och det kommer att ange objektets x- och y-egenskaper till de angivna värdena.
Dummy-kommandot gör ingenting och fullbordar kommandotillverkningen. Syftet med detta kommando är att fungera som en "platshållare" och kommer att bli tydlig senare:
paketkommandon.utils import commands.Command; // detta kommando gör helt enkelt ingenting och fullbordar sig på exekvering offentlig klass Dummy sträcker kommandot allmän funktion Dummy () åsidosätter skyddad funktion exekvera (): void complete ();
Wait-kommandot väntar på en viss mängd fördröjningstid och avslutar sedan körning utan att göra någonting:
paketkommandon.utils import commands.Command; allmän klass Vänta utökar kommando offentlig funktion Vänta (fördröjning: Nummer = 0) super (fördröjning); åsidosätta skyddad funktion exekvera (): void complete ();
Du kanske undrar varför vi skulle behöva ett kommando som helt enkelt upptar tid om vi redan har en "fördröjning" -konstruktörsparameter i baskommandoklassen. Ibland vill vi utforma konstruktörer för att bara ha parametrar som verkligen har något att göra med kommandos specifika funktionalitet, och inklusive "fördröjning" -tiden, eftersom en parameter bland dem är typ av att avbryta "likformighet" när det gäller parametrar. Så istället för att skriva koden nedan:
ny SerialCommand (0, ny SomeFancyCommand (delay1, fancyParam11, fancyParam12, fancyParam31), ny SomeFancyCommand (delay2, fancyParam21, fancyParam22, fancyParam23));
Vi kunde skriva något så här:
Ny SerialCommand (0, New Wait (delay1), New SomeFancyCommand (fancyParam11, fancyParam12, fancyParam31), New Wait (delay2), nya SomeFancyCommand (fancyParam21, fancyParam22, fancyParam23));
Parametrarna "fördröjning" tar inte längre dina onödiga ögon i SomeFancyCommand-konstruktörerna. De har nu flyttats till Wait-kommandona för att göra saker renare.
Här är vår scenklass, som representerar en enda "pusselbit". Vad varje metod gör förklaras i kommentarerna. Denna klass är ganska mycket en "skelett" -klass, eftersom varje metod antingen skapar ett dummy-kommando eller gör ingenting. För att få saker juicier måste dessa metoder överdrivas. Skapa en ny "scenes" -katalog i projektets källkatalog för att lagra dessa nya klasser:
paket scener import commands.Command; importera kommandon.utils.Dummy; // den här klassen representerar en scen för en komplett Flash-applikation offentlig klassplats // en referens till scenhanteraren som äger denna scen intern var _sceneManager: SceneManager; skyddad slutfunktion få scenManager (): SceneManager return _sceneManager; // skapar intro-kommandot för den här scenens offentliga funktion createIntroCommand (): Command return new Dummy (); // skapar outro-kommandot för den här scenens offentliga funktion createOutroCommand (): Command return new Dummy (); // hantera scenrelaterade saker här när scenen är inställd offentlig funktion onSceneSet (): void
Och här är SceneManager-klassen som hanterar scenövergångar, detaljerna förklaras också i kommentarerna. Observera att jag har lagt till en "dummy-proof variabel" för att skydda övergångar från att brytas av otillbörlig anrop till metoden setScene ().
paket scener import commands.Command; importera flash.events.Event; // den här klassen hanterar scenövergångar offentlig klass SceneManager // en referens till den aktuella scenen privat var _currentScene: Scene; // en referens till målplatsen för en övergång privat var _targetScene: Scene; // dummy-proof variabel privat var _isInTransition: Boolean = false; public function SceneManager () public function setScene (scen: Scene): void // om en övergång inte är färdig, ignorera metodanropet om (_isInTransition) returnerar; _targetScene = scen; // Slå på den dummy-säkra variabeln _isInTransition = true; // kontrollera om en scen redan är tilldelad till scenhanteraren om (_currentScene) // om ja, starta omstart av den aktuella scenen first var outroCommand: Command = _currentScene.createOutroCommand (); // och lyssna på den fullständiga händelsen av Outro-kommandot outroCommand.addEventListener (Event.COMPLETE, onCurrentOutroComplete); outroCommand.start (); annars // om inte, starta introen av målscenen gotoTargetScene (); // anropas när outro-kommandot för den aktuella scenen är fullständig privat funktion onCurrentOutroComplete (e: Event): void Command (e.target) .removeEventListener (Event.COMPLETE, onCurrentOutroComplete); gotoTargetScene (); privat funktion gotoTargetScene (): void // ställa in scenhanteringsreferensen för målscenen till denna _targetScene._sceneManager = this; var introCommand: Command = _targetScene.createIntroCommand (); // lyssna på den fullständiga händelsen av intro-kommandot för målscenen introCommand.addEventListener (Event.COMPLETE, onTargetIntroComplete); introCommand.start (); // anropas när intro-kommandot för målscenen är fullständig privat funktion onTargetIntroComplete (e: Event): void Command (e.target) .removeEventListener (Event.COMPLETE, onTargetIntroComplete); // ta bort scenhanterarens referens för föregående scen om (_currentScene) _currentScene._sceneManager = null; // ställa in målscenen som den aktuella scenen _currentScene = _targetScene; // stäng av dummy-säker variabel _isInTransition = false; // och anropa metoden onSceneSet () _currentScene.onSceneSet ();
Okej. Allt är klart och vi är redo att gå. Det är dags att skapa en verklig applikation med det ramverk vi byggt.
Öppna Flash IDE och skapa ett nytt Flash-dokument. Namnge det "SceneTransitions" och skapa en dokument klass med samma namn. Du kan också placera en bakgrund på scenen om du vill.
Skapa 4 symboler med text och namnge dem enligt följande bild. I det här exemplet exporterar du varje symbol för ActionScript med ett klassnamn som är detsamma som dess symbolnamn.
Skapa symboler och namnge dem enligt bilden nedan. Också, layout deras exempel och namnge dem som visat. Välj alla instanser och konvertera dem, som en grupp, till en annan symbol med namnet "Scene1Sprite". Du kan sedan radera Scene1Sprite från scenen (men inte från biblioteket).
Gör exakt samma som föregående steg, men den här gången väljer du alla instanser och konverterar dem till en symbol med namnet "Scene2Sprite."
Dokumentklassen är överraskande enkel. Skapa bara en scenhanterare och berätta för chefen att ställa in den aktuella scenen till en introscene.
paket import flash.display.Sprite; import scenes.SceneManager; public class SceneTransitions utökar Sprite public function SceneTransitions () var sceneManager: SceneManager = new SceneManager (); sceneManager.setScene (ny IntroScene (this));
Den första scenen vi ställer in för scenschefen är en introscene. Som namnet antyder är denna scen helt enkelt ett intro till vår huvudplats (snarare än att vara introdelen av vår huvudscenes "pusselbit"). Intro-kommandot (skapat från överstyrningen createIntroCommand () -metoden) på den här introscenen flyttar instanser av symboler till mitten av scenen (genom kommandot SetProperties), lägger dem till behållaren, tweens dem från nollskala till 100% skala, och försvinner dem till noll alfa, en efter varandra. Detta uppnås genom att länka alla separata kommandon tillsammans med ett enda seriekommando (som du bör komma ihåg från del ett).
När intro-kommandot är färdigt påbereds metoden onSceneSet (), och vid denna tidpunkt är egenskapen sceneManager tillgänglig, och metoden setScene () kan användas för att byta scen. I metoden onSceneSet () anropas scenhanterarens setScene () -metod för att växla till Scene1 (en klass som vi kommer att skapa i nästa steg). Eftersom vi inte åsidosatte CreateOutroCommand () är Outro-kommandot på introscenen ett dummy-kommando, vilket gör ingenting.
paket import commands.Command; importera kommandon.display.AddChild; importera kommandon.display.RemoveChild; importera kommandon.greensock.TweenMaxFrom; importera kommandon.greensock.TweenMaxTo; importera kommandon.scenes.SetScene; import commands.SerialCommand; importera kommandon.utils.SetProperties; importera flash.display.DisplayObject; importera flash.display.Sprite; importera flash.filters.BlurFilter; import scenes.Scene; public class IntroScene utökar scenen // konstanta parametrar privat statisk const ZOOM_IN_TIME: Number = 0.2; privat statisk konst HOLD_TIME: Number = 0.3; privat statisk konst BLUR_OUT_TIME: Number = 0.2; privat statisk konst BLUR_AMOUNT: Number = 20; privat var container: Sprite; offentlig funktion IntroScene (behållare: Sprite) this.container = container; åsidosätta den offentliga funktionen createIntroCommand (): Command var oskärpa: BlurFilter = ny BlurFilter (BLUR_AMOUNT, BLUR_AMOUNT, 2); // symbol instances var text1: DisplayObject = ny IntroText1 (); var text2: DisplayObject = ny IntroText2 (); var text3: DisplayObject = ny IntroText3 (); var text4: DisplayObject = ny IntroText4 (); // detta är det seriella kommandot som länkar saker tillsammans var kommando: Kommandot = nytt SerialCommand (0, // "THIS" nya SetProperties (text1, x: 320, y: 200), nytt AddChild (container, text1) ny TweenMaxFrom (text1, ZOOM_IN_TIME, scaleX: 0, skalaY: 0), ny TweenMaxTo (text1, BLUR_OUT_TIME, fördröjning: HOLD_TIME, alfa: 0, blurFilter: blur), nytt RemoveChild (container, text1) "New ISP" (text2, x: 320, y: 200), ny AddChild (container, text2), ny TweenMaxFrom (text2, ZOOM_IN_TIME, scaleX: 0, skalaY: 0), ny TweenMaxTo BLUR_OUT_TIME, fördröjning: HOLD_TIME, alfa: 0, blurFilter: blur), nytt RemoveChild (container, text2), // "AN" nya SetProperties (text3, x: 320, y: 200), nytt AddChild , text3), ny TweenMaxFrom (text3, ZOOM_IN_TIME, scaleX: 0, skalaY: 0), ny TweenMaxTo (text3, BLUR_OUT_TIME, fördröjning: HOLD_TIME, alfa: 0, blurFilter: blur), nytt RemoveChild (container, text3 ), // "INTRO" nya SetProperties (text4, x: 320, y: 200), nya AddChild (container, text4), nya TweenMaxFrom (text4, ZOOM_IN_TIM E, skalaX: 0, skalaY: 0), ny TweenMaxTo (text4, BLUR_OUT_TIME, fördröjning: HOLD_TIME, alfa: 0, blurFilter: blur), nytt RemoveChild (container, text4),); returnera kommandot; åsidosätta den offentliga funktionen onSceneSet (): void // när scenen är inställd, gå direkt till scen 1 sceneManager.setScene (ny Scene1 (container));
Du kan justera värdet på consts för att ändra tweening effekterna.
Låt oss nu titta på Scene1-klassen. Textfälten är tweened i position one-by-one; "intro_btn" och "scene2_btn" -knapparna är registrerade med musklickhändelselysare efter att de är tweened i position, uppnås genom att kedja samman kommandon för tweening och lägga till lyssnare med ett seriellt kommando.
En annan sak som är värt att nämna är AddChild-kommandot som lägger till Scene1Sprite i behållaren. Den är sammanfogad i serie efter ett Wait-kommando som väntar på en ram. Eftersom klassen TweenMax uppdaterar alla visningsobjekt i nästa ram efter Samtalet till TweenMax.from () -metoden, ibland kan du se en snabb "glimt" av objekt i sina slutliga platser, innan tweening startar. Syftet med Wait-kommandot här är att ge TweenMax tillräckligt med tid för att flytta objekt till sina riktiga startplatser.
paket import commands.Command; importera kommandon.display.AddChild; importera kommandon.display.RemoveChild; importera kommandon.events.AddEventListener; importera kommandon.events.RemoveEventListener; importera kommandon.greensock.TweenMaxFrom; importera kommandon.greensock.TweenMaxTo; importera kommandon.ParallelCommand; import commands.SerialCommand; importera kommandon.utils.SetProperties; importera kommandon.utils.Wait; importera flash.display.Sprite; importera flash.events.Event; importera flash.events.MouseEvent; importera flash.filters.BlurFilter; import scenes.Scene; public class Scene1 utökar scenen // konstanta parametrar privat statisk const IN_TIME: Number = 0.4; privat statisk konst OUT_TIME: Number = 0.2; privat statisk konst DELAY_TIME: Number = 0.2; privat statisk konst BLUR_AMOUNT: Number = 20; privat var container: Sprite; privata var: Scen1Sprite; privat var oskärpa: BlurFilter; allmän funktion Scene1 (behållare: Sprite) this.container = container; ss = ny Scene1Sprite (); åsidosätta allmän funktion createIntroCommand (): Command varkommando: Kommando = ny ParallelCommand (0, // "THIS" ny TweenMaxFrom (ss.text1_mc, IN_TIME, x: -400), // "IS" ny TweenMaxFrom ss.text2_mc, IN_TIME, y: -250, fördröjning: DELAY_TIME), // "SCENE" ny TweenMaxFrom (ss.text3_mc, IN_TIME, y: 250, fördröjning: DELAY_TIME * 2), // "1" ny TweenMaxFrom (ss.text4_mc, IN_TIME, x: 400, fördröjning: DELAY_TIME * 3), // introknapp ny SerialCommand (0, ny TweenMaxFrom (ss.intro_btn, IN_TIME, y: 250, fördröjning: DELAY_TIME * 4 ), ny AddEventListener (ss.intro_btn, MouseEvent.CLICK, replayIntro)), // scen 2-knappen, nya SerialCommand (0, nya TweenMaxFrom (ss.scene2_btn, IN_TIME, y: 250, försening: DELAY_TIME * 5) nya AddEventListener (ss.scene2_btn, MouseEvent.CLICK, gotoScene2)), // flytta scenen 1 sprite till mitten av behållaren nya SetProperties (ss, x: 300, y: 200), // lägg till scen 1 sprite till behållaren // vänta på en ram för att tillåta att saker flyttas till rätt plats Nya SerialCommand (0, New Wait (1 / containe r.stage.frameRate), nya AddChild (container, ss))); returnera kommandot; åsidosätta den offentliga funktionen createOutroCommand (): Command var oskärpa: BlurFilter = ny BlurFilter (BLUR_AMOUNT, BLUR_AMOUNT, 3); var command: Command = new ParallelCommand (0, // ta bort visningsobjekten nya SerialCommand (0, // "THIS" nya TweenMaxTo (ss.text1_mc, OUT_TIME, ala: 0, blurFilter: blur), // "IS" NEW TweenMaxTo (ss.text2_mc, OUT_TIME, ala: 0, blurFilter: oskärpa), // "SCENE" ny TweenMaxTo (ss.text3_mc, OUT_TIME, ala: 0, blurFilter: oskärpa), // "1" ny TweenMaxTo (ss.text4_mc, OUT_TIME, ala: 0, blurFilter: oskärpa), // introknappen ny TweenMaxTo (ss.intro_btn, OUT_TIME, alfa: 0, blurFilter: oskärpa), // scen 2 knapp ny TweenMaxTo (ss.scene2_btn, OUT_TIME, ala: 0, blurFilter: oskärpa), // ta bort scen 1 sprite new RemoveChild (container, ss)), // ta bort händelselyttare nya RemoveEventListener (ss.intro_btn, MouseEvent.CLICK, replayIntro), nya RemoveEventListener (ss.scene2_btn, MouseEvent.CLICK, gotoScene2)); returnera kommandot; privat funktion replayIntro (e: Event): void sceneManager.setScene (ny IntroScene (container)); privat funktion gotoScene2 (e: Event): void sceneManager.setScene (new Scene2 (container));
Scene2-klassen ser ungefär ut som Scene1; men viss text ändras:
paket import commands.Command; importera kommandon.display.AddChild; importera kommandon.display.RemoveChild; importera kommandon.events.AddEventListener; importera kommandon.events.RemoveEventListener; importera kommandon.greensock.TweenMaxFrom; importera kommandon.greensock.TweenMaxTo; importera kommandon.ParallelCommand; import commands.SerialCommand; importera kommandon.utils.SetProperties; importera kommandon.utils.Wait; importera flash.display.Sprite; importera flash.events.Event; importera flash.events.MouseEvent; importera flash.filters.BlurFilter; import scenes.Scene; public class Scene2 utökar scenen // konstanta parametrar privat statisk const IN_TIME: Number = 0.4; privat statisk konst OUT_TIME: Number = 0.2; privat statisk konst DELAY_TIME: Number = 0.2; privat statisk konst BLUR_AMOUNT: Number = 20; privat var container: Sprite; privat var: Scene2Sprite; privat var oskärpa: BlurFilter; allmän funktion Scene2 (container: Sprite) this.container = container; ss = ny Scene2Sprite (); åsidosätta allmän funktion createIntroCommand (): Command varkommando: Kommando = ny ParallelCommand (0, // "... OCH" ny TweenMaxFrom (ss.text1_mc, IN_TIME, x: -400), // "DETTA ÄR" ny TweenMaxFrom (ss.text2_mc, IN_TIME, y: -250, fördröjning: DELAY_TIME), // "SCENE" ny TweenMaxFrom (ss.text3_mc, IN_TIME, y: 250, fördröjning: DELAY_TIME * 2), // " 2 "ny TweenMaxFrom (ss.text4_mc, IN_TIME, x: 400, fördröjning: DELAY_TIME * 3), // introknapp ny SerialCommand (0, ny TweenMaxFrom (ss.intro_btn, IN_TIME, y: 250, fördröjning: DELAY_TIME * 4), nya AddEventListener (ss.intro_btn, MouseEvent.CLICK, replayIntro)), // scen 1-knappen, nya SerialCommand (0, nya TweenMaxFrom (ss.scene1_btn, IN_TIME, y: 250, försening: DELAY_TIME * 5 ), nya AddEventListener (ss.scene1_btn, MouseEvent.CLICK, gotoScene1)), // flytta scenen 2 sprite till mitten av behållaren nya SetProperties (ss, x: 300, y: 200), // lägg till scen 2 sprite till behållaren // vänta på en ram för att tillåta att saker flyttas till rätt plats Nya SerialCommand (0, New Wait (1 / container.stage.frameRate), nya AddChild (container, ss))); returnera kommandot; åsidosätta den offentliga funktionen createOutroCommand (): Command var oskärpa: BlurFilter = ny BlurFilter (BLUR_AMOUNT, BLUR_AMOUNT, 3); var command: Command = new ParallelCommand (0, // ta bort visningsobjekten nya SerialCommand (0, // "THIS" nya TweenMaxTo (ss.text1_mc, OUT_TIME, ala: 0, blurFilter: blur), // "IS" new TweenMaxTo (ss.text2_mc, OUT_TIME, alfa: 0, blurFilter: blur), // "SCENE" ny TweenMaxTo (ss.text3_mc, OUT_TIME, ala: 0, blurFilter: blur), // "2" ny TweenMaxTo (ss.text4_mc, OUT_TIME, ala: 0, blurFilter: oskärpa), // introknapp ny TweenMaxTo (ss.intro_btn, OUT_TIME, alfa: 0, blurFilter: oskärpa), // scen 1 knapp ny TweenMaxTo (ss.scene1_btn, OUT_TIME, alpha: 0, blurFilter: oskärpa), // ta bort scen 1 sprite new RemoveChild (container, ss)), // ta bort händelselyttare nya RemoveEventListener (ss.intro_btn, MouseEvent.CLICK, replayIntro), ny RemoveEventListener (ss.scene1_btn, MouseEvent.CLICK, gotoScene1)); returnera kommandot; privat funktion replayIntro (e: Event): void sceneManager.setScene (ny IntroScene (container)); privat funktion gotoScene1 (e: Event): void sceneManager.setScene (new Scene1 (container));
Det är rätt, vi är äntligen färdiga! Tryck CTRL + ENTER i Flash IDE för att testa filmen och se de smidiga och sömlösa övergångarna mellan scenerna.
I denna handledning har vi byggt egna kommando- och scenhanteringsramar. Vi har gått igenom en hel del kod, men det är helt värt det. Nu när vi har dessa ramar till hands, är scenhantering gjord med lättförståelig och underhållbar kod. Varje Flash-applikation kan brytas ner i scener, och varje scen består av intro och outro-kommandon. Instruktionerna inkapslas i kommandon, vilket resulterar i enhetligt "kodutseende", vilket gör det möjligt för oss att hantera scenintro och outro på ett väldigt högt sätt.
Jag hoppas att du njöt av det, tack för att du läste!
Accentsconagua