Share
În acest tutorial vom extinde în continuare cadrul de comandă din prima parte. Vom crea un cadru de gestionare a scenelor, cu un cod ușor de înțeles și susținut.
Să aruncăm o privire la rezultatul final la care vom lucra:
O abordare rezonabilă pentru a rupe o aplicație Flash completă în bucăți mai mici este să o gestionați ca scene separate. Flash IDE vă permite să efectuați gestionarea scenelor fără a scrie niciun cod, dar vom aborda lucrurile cu totul altfel. Vom crea propriul cadru de management al scenelor.
În cadrul nostru de gestionare a scenelor, considerăm scenele drept cele mai mici blocuri de construcție pentru o aplicație Flash completă. Fiecare scenă este alcătuită dintr-un introducere și o comandă outro comanda. O comandă intro inițializează tot ce aveți nevoie pentru o scenă, cum ar fi adăugarea unui logo în lista de afișare a sprite-ului dvs. de container. O comandă outro face exact contrariul, cum ar fi eliminarea logo-ului din sprite-ul containerului. Puteți vedea tranziția de la o scenă la alta ca comandă outro a primei scene urmată de comanda intro a celei de-a doua. În acest fel, putem pune scene împreună și le putem gestiona ușor tranzițiile.
Uitați-vă la această cifră. O scenă este ca o piesă a unui puzzle; capătul din stânga reprezentând comanda intro și capătul drept fiind comanda outro.
Efectuarea unei tranziții de la scena A la scena B este la fel ca conectarea celor două piese împreună. Comanda outro a scenei A este executată mai întâi, comanda intro a scenei B este executată în continuare, apoi tranziția scena este finalizată.
Este în esență exact același concept pentru a efectua o tranziție de la scena A la scena C. Trebuie doar să punem piesele de puzzle A și C împreună, în loc de A și B.
Înainte de a începe construirea cadrului de gestionare a scenei, să creăm mai întâi câteva clase de comandă care vor fi ulterior utilizate în acest tutorial. Puteți doar să vă concentrați asupra metodelor execute () de executare ale următoarelor clase de comandă, care reprezintă cea mai importantă parte a acestor clase.
Fără îndoială, Platforma GreenSock Tweening este unul dintre cele mai bune cadre de tweening open source. Scenariile de tranziție implică, de obicei, multe adăugări, iar Platforma GreenSock Tweening a fost dintotdeauna prima mea alegere atunci când vine vorba de crearea de tweens. Vom încapsula acest cadru în clase de comandă pentru al integra în cadrul nostru de comandă. Descărcați biblioteca TweenMax și instalați-o.
Vom folosi metodele () și din () din clasa TweenMax. Clasa TweenMax oferă o modalitate de a gestiona finalizarea unui tween invocând o funcție menționată de proprietatea opțională "onComplete" în parametrul "vars". Vom asocia metoda completă () a comenzii la această proprietate, astfel încât metoda completă () este invocată când se termină adăugarea. Mai jos este codul pentru comenzile care încapsulează aceste două metode. Creați un nou director numit "greensock" în directorul "comenzi" pe care l-ați creat în prima parte a acestui tutorial și salvați aceste clase ca TweenMaxTo.as și respectiv TweenMaxFrom.as.
pachet comenzi.greensock import com.greensock.TweenMax; comenzi de import.Command; // această comandă încapsulează metoda TweenMax.to () public class TweenMaxTo extinde Command public var target: Object; public var duration: Număr; public var vars: obiect; funcția publică TweenMaxTo (țintă: Obiect, durată: Număr, vars: Obiect) this.target = țintă; this.duration = duration; this.vars = vars; suprascrie funcția protejată execute (): void // spuneți TweenMax pentru a invoca metoda completă () a comenzii când finalizarea este terminată vars.onComplete = completă; TweenMax.to (ținta, durata, vars);
pachet comenzi.greensock import com.greensock.TweenMax; comenzi de import.Command; // această comandă încapsulează metoda TweenMax.from () public class TweenMaxFrom extinde Command public var target: Object; public var duration: Număr; public var vars: obiect; funcția publică TweenMaxFrom (țintă: Obiect, durată: Număr, vars: Obiect) this.target = țintă; this.duration = duration; this.vars = vars; suprascrie funcția protejată execute (): void // spuneți TweenMax pentru a invoca metoda completă () a comenzii când finalizarea este terminată vars.onComplete = completă; TweenMax.from (țintă, durată, vars);
(Asigurați-vă că re-citiți introducerea mea în comenzi dacă aveți nevoie să vă reîmprospătați memoria.)
TweenMaxTo va aduce obiectul țintă din poziția sa actuală (sau estompare, sau alfa, sau ...) în noua poziție (etc) pe care o specificați cu obiectul vars. TweenMaxFrom face opusul.
Dacă sunteți destul de familiarizat cu platforma GreenSock Tweening, ați putea dori, de asemenea, să încapsulați clasele TweenLite și TweenNano pentru a se potrivi nevoilor dvs..
După cum am menționat anterior, intro și outro de o scenă pot implica, probabil, adăugarea obiectelor de afișare la un container de obiecte de afișare și eliminarea obiectelor din container. Deci, haideți să încapsulați comenzile addChild () și removeChild ().
comenzi de pachete.display import commands.Command; import flash.display.DisplayObject; import flash.display.DisplayObjectContainer; // Această comandă încapsulează metoda addChild () public class AddChild extinde Command public var container: DisplayObjectContainer; public var displayObject: Funcția publică DisplayObject AddChild (container: DisplayObjectContainer, displayObject: DisplayObject) this.container = container; this.displayObject = displayObject; suprascrie funcția protejată execute (): void container.addChild (displayObject); complet();
comenzi de pachete.display import commands.Command; import flash.display.DisplayObject; import flash.display.DisplayObjectContainer; // Această comandă încapsulează metoda removeChild () public class RemoveChild extinde Command public var container: DisplayObjectContainer; public var displayObject: funcția publică DisplayObject RemoveChild (container: DisplayObjectContainer, displayObject: DisplayObject) this.container = container; this.displayObject = displayObject; suprascrie funcția protejată execute (): void container.removeChild (displayObject); complet();
De asemenea, vom folosi comenzi pentru a face față adăugării și eliminării ascultătorilor evenimentului, deci să încapsulam metodele addEventListener () și removeEventListener ().
pachete commands.events import commands.Command; import flash.events.IEventDispatcher; // această comandă încapsulează metoda addEventListener () public class AddEventListener extinde Command public var dispatcher: IEventDispatcher; tip public var: String; public var listener: Funcția; funcția publică AddEventListener (dispecer: IEventDispatcher, tip: String, ascultător: Funcție) this.dispatcher = dispecer; this.type = type; this.listener = ascultător; suprascrie funcția protejată execute (): void dispatcher.addEventListener (type, listener); complet();
pachete commands.events import commands.Command; import flash.events.IEventDispatcher; // această comandă încapsulează metoda removeEventListener () public class RemoveEventListener extinde Command public var dispatcher: IEventDispatcher; tip public var: String; public var listener: Funcția; funcția publică RemoveEventListener (dispecer: IEventDispatcher, tip: String, ascultător: Funcție) this.dispatcher = dispecer; this.type = type; this.listener = ascultător; suprascrie funcția protejată execute (): void dispatcher.removeEventListener (type, listener); complet();
În cele din urmă, vom avea nevoie de niște comenzi utilitare pentru a face lucrurile mai ușoare. Comanda SetProperties stabilește proprietățile unui obiect din valorile de proprietate ale unui alt obiect:
pachet comands.utils import commands.Command; // această comandă stabilește proprietățile obiectului într-un mod rapid și convenabil clasa publică SetProperties extinde Command public var target: Object; proprietăți publice var: Obiect; funcția publică SetProperties (țintă: Obiect, proprietăți: Obiect) this.target = țintă; this.properties = proprietăți; suprascrie funcția protejată execute (): void pentru (var var: String în proprietăți) target [key] = proprietăți [key]; complet();
Putem folosi așa:
var setProperties: SetProperties = SetProperties nou (țintă, x: 100, y: 230);
... și va seta proprietățile x și y ale obiectului țintă la valorile specificate.
Comanda Dummy nu face nimic și completează execuția comenzii. Scopul acestei comenzi este de a servi ca un "substituent" și va deveni clar mai târziu:
pachet comands.utils import commands.Command; // această comandă nu face nimic și se completează singură pe execuția clasei publice Dummy extinde Command function public Dummy () suprascrie funcția protejată execute (): void complete ();
Comanda așteptare așteaptă o anumită sumă de timp de întârziere și apoi execută execuția comenzii fără a face nimic:
pachet comands.utils import commands.Command; clasa publica Așteptare extinde Comanda funcția publică Așteptați (întârziere: număr = 0) super (întârziere); suprascrie funcția protejată execute (): void complete ();
S-ar putea să vă întrebați de ce am avea nevoie de o comandă care pur și simplu ocupă timp dacă avem deja un parametru constructor "întârziere" în clasa de comandă de bază. Uneori ne-am propus să construim constructori numai pentru a avea parametri care au într-adevăr ceva de-a face cu funcționalitatea specifică a comenzii și includerea timpului de "întârziere" ca un parametru între ei este un fel de întrerupere a "uniformității" în termenii scopurilor parametrilor. Deci, în loc de a scrie codul de mai jos:
comanda noua SerialCommand (0, newFancyCommand (delay1, fancyParam11, fancyParam12, fancyParam31), newFancyCommand (delay2, fancyParam21, fancyParam22, fancyParam23));
Am putea scrie ceva de genul:
comanda nouă (0, nouă așteptare (întârziere1), newFancyCommand (fancyParam11, fancyParam12, fancyParam31), noul așteptare (întârziere2), newFancyCommand (fancyParam21, fancyParam22, fancyParam23));
Parametrii de "întârziere" nu vă mai văd în mod inutil ochii în constructorii SomeFancyCommand. Ei au fost mutați acum în comenzile Așteptați pentru a face lucrurile mai curate.
Iată clasa noastră de scenă, reprezentând o singură "piesă de puzzle". Ceea ce face fiecare metodă este explicat în comentarii. Această clasă este destul de mult o clasă "schelet", deoarece fiecare metodă creează o comandă falsă sau nu face nimic. Pentru a face lucrurile mai sustinute, aceste metode trebuie sa fie suprasolicitate. Creați un nou director "scenarii" în directorul sursă al proiectului pentru a stoca aceste clase noi:
pachete scenelor import comenzi.Command; import commands.utils.Dummy; // această clasă reprezintă o scenă pentru o aplicație completă de aplicații Flash Scene publică // o referință la managerul de scenă care deține această scena interioară var _sceneManager: SceneManager; funcția finală protejată obține scenaManager (): SceneManager return _sceneManager; // creează comanda intro a acestei funcții publice scena createIntroCommand (): Command return new Dummy (); // creează comanda outro a acestei funcții publice scena createOutroCommand (): Command return new Dummy (); // manipulați chestiile legate de scenă aici când scena este setată pe funcția publică onSceneSet (): void
Și aici este clasa SceneManager care se ocupă de tranzițiile de scenă, detalii explicate și în comentarii. Rețineți că am adăugat o "variabilă falsă" pentru a proteja tranzițiile de a fi sparte prin invocarea prealabilă a metodei setScene ().
pachete scenelor import comenzi.Command; importul flash.events.Event; // această clasă se ocupă de tranzițiile scena clasa publică SceneManager // o referință la scena curentă privată var _currentScene: Scene; // o referință la scena țintă a unei variabile private var _targetScene: Scene; // dummy-dovada variabilă privată var _isInTransition: Boolean = false; funcția publică SceneManager () funcția publică setScene (scena: Scene): void // dacă o tranziție nu este terminată, ignorați invocarea metodei dacă returnarea (_isInTransition) _targetScene = scenă; // activați variabila proof-proof _isInTransition = true; // verifica daca scena este deja atribuita managerului de scena daca (_currentScene) // daca da, porneste outro scena curenta var var outroCommand: Command = _currentScene.createOutroCommand (); // și ascultați pentru evenimentul complet al comenzii outroCommand.addEventListener (Event.COMPLETE, onCurrentOutroComplete); outroCommand.start (); altfel // dacă nu, porniți intro scena țintă gotoTargetScene (); // invocată atunci când comanda outro a scenei curente este completă privată a funcției onCurrentOutroComplete (e: Event): void Command (e.target) .removeEventListener (Event.COMPLETE, onCurrentOutroComplete); gotoTargetScene (); funcția privată gotoTargetScene (): void // setați referința managerului de scenă a scenei țintă la acest _targetScene._sceneManager = this; var introCommand: Comandă = _targetScene.createIntroCommand (); // ascultați pentru evenimentul complet al comenzii intro a scenei țintă introCommand.addEventListener (Event.COMPLETE, onTargetIntroComplete); introCommand.start (); // invocat când comanda intro a scenei țintă este completă privată onTargetIntroComplete (e: Event): void Command (e.target) .removeEventListener (Event.COMPLETE, onTargetIntroComplete); // eliminați referința managerului scena de pe scena anterioară dacă (_currentScene) _currentScene._sceneManager = null; // setați scena țintă ca scena curentă _currentScene = _targetScene; // dezactivați variabila provizorie dummy _isInTransition = false; // și invocați metoda onSceneSet () _currentScene.onSceneSet ();
Bine. Totul e setat și suntem gata să plecăm. Este timpul să creați o aplicație reală cu cadrul pe care l-am construit.
Deschideți IDE-ul Flash și creați un nou document Flash. Denumiți-o "SceneTransitions" și creați o clasă de documente cu același nume. De asemenea, aveți posibilitatea să plasați un fundal pe scenă dacă doriți.
Creați 4 simboluri cu text și denumiți-le în funcție de imaginea următoare. În acest exemplu, exportați fiecare simbol pentru ActionScript cu un nume de clasă care este același cu numele simbolului său.
Creați simboluri și denumiți-le după cum se arată în imaginea următoare. De asemenea, configurați instanțele și denumiți-le după cum se arată. Selectați toate instanțele și convertiți-le, ca grup, la un alt simbol, numit "Scene1Sprite". Apoi, puteți șterge Scene1Sprite din etapă (dar nu din bibliotecă).
Faceți exact același pas ca înainte, dar de data aceasta selectați toate instanțele și convertiți-le la un simbol numit "Scene2Sprite".
Clasa de documente este surprinzător de simplă. Doar creați un manager de scenă și spuneți managerului să stabilească scena curentă într-o scenă intro.
pachet import flash.display.Sprite; Scene de import.SceneManager; clasa publică SceneTransitions extinde Sprite funcția publică SceneTransitions () var sceneManager: SceneManager = nou SceneManager (); sceneManager.setScene (noua IntroScene (aceasta));
Scena inițială pe care o stabilim pentru managerul de scenă este o scenă intro. După cum sugerează și numele, această scenă este pur și simplu un intro la scena noastră principală (mai degrabă decât a fi partea intro a piesei puzzle-ului principal al scenei noastre). Comanda intro (creată de metoda override createIntroCommand ()) a acestei scene intro mută exemple de simboluri în centrul stadiului (prin comanda SetProperties), le adaugă la container, le tweens de la scară zero la scală de 100% și le estompează la zero alfa, unul după altul. Acest lucru se realizează prin conectarea tuturor comenzilor separate împreună cu o singură comandă serială (așa cum ar trebui să vă amintiți din partea a patra).
Când comanda intro este finalizată, metoda onSceneSet () este invocată și în acest moment proprietatea sceneManager este disponibilă și metoda setScene () poate fi invocată pentru comutarea scenei. În metoda onSceneSet (), metoda setScene () a managerului de scenă este invocată pentru a trece la Scena1 (o clasă pe care o vom crea în pasul următor). Pe măsură ce nu am suprascrie createOutroCommand (), comanda outro a scenei intro este o comandă fictivă, care nu face nimic.
pachet import commands.Command; import commands.display.AddChild; import commands.display.RemoveChild; import commands.greensock.TweenMaxFrom; import commands.greensock.TweenMaxTo; import comenzi.scenes.SetScene; comenzi de import.SerialCommand; import commands.utils.SetProperties; import flash.display.DisplayObject; import flash.display.Sprite; import flash.filters.BlurFilter; scenarii de import.Scene; clasa publică IntroScene extinde Scena // parametrii constanți static const const ZOOM_IN_TIME: Number = 0.2; statică statică privată HOLD_TIME: Number = 0.3; static static privat BLUR_OUT_TIME: Number = 0.2; constr. statică privată BLUR_AMOUNT: Număr = 20; container privat var: Sprite; funcția publică IntroScene (container: Sprite) this.container = container; suprascrie funcția publică createIntroCommand (): Command var blur: BlurFilter = BlurFilter nou (BLUR_AMOUNT, BLUR_AMOUNT, 2); // simbol instances var text1: DisplayObject = new IntroText1 (); var text2: DisplayObject = nou IntroText2 (); var text3: DisplayObject = nou IntroText3 (); var text4: DisplayObject = nou IntroText4 (); // aceasta este comanda serial care leagă lucrurile împreună comanda var: Command = new SerialCommand (0, // "ACEST" nou SetProperties (text1, x: 320, y: 200 noul TweenMaxFrom (text1, ZOOM_IN_TIME, scaleX: 0, scaleY: 0), noul TweenMaxTo (text1, BLUR_OUT_TIME, întârziere: HOLD_TIME, alfa: 0, blurFilter: blur "IS" nou SetProperties (text2, x: 320, y: 200), noul AddChild (container, text2), noul TweenMaxFrom (text2, ZOOM_IN_TIME, scaleX: 0, scaleY: BLUR_OUT_TIME, întârziere: HOLD_TIME, alfa: 0, blurFilter: blur), new RemoveChild (container, text2), // newName SetProperties (text3, x: 320, y: , text3), noua versiune TweenMaxFrom (text3, ZOOM_IN_TIME, scaleX: 0, scaleY: 0), noul TweenMaxTo (text3, BLUR_OUT_TIME, delay: HOLD_TIME, alfa: 0, blurFilter: ), // INTRO noi SetProperties (text4, x: 320, y: 200), noul AddChild (container, text4), noul TweenMaxFrom (text4, ZOOM_IN_TIM E, scaleX: 0, scaleY: 0), noul TweenMaxTo (text4, BLUR_OUT_TIME, întârziere: HOLD_TIME, alfa: 0, blurFilter: blur), new RemoveChild (container4); comanda retur; suprascrie funcția publică onSceneSet (): void // atunci când scena este setată, mergeți direct la scena 1 sceneManager.setScene (nou Scene1 (container));
Aveți posibilitatea să ajustați valoarea consts pentru a modifica efectele de îmbunătățire.
Acum, să ne uităm la clasa Scene1. Câmpurile de text sunt completate în poziția unu-câte unul; butoanele "intro_btn" și "scene2_btn" sunt înregistrate cu ascultători de evenimente de pe mouse-clic după ce au fost adăugate în poziție, obținute prin legarea împreună a comenzilor pentru adăugarea și adăugarea ascultătorilor cu o comandă serială.
Un alt lucru care merită menționat este comanda AddChild care adaugă Scene1Sprite la container. Este concatenat în serie după o comandă de așteptare care așteaptă un cadru. Deoarece clasa TweenMax actualizează toate obiectele de afișare din cadrul următor după apelul la metoda TweenMax.from (), uneori este posibil să vedeți o scurtă "aruncare" a obiectelor în locurile lor finale, înainte de începerea tweening-ului. Scopul comenzii Așteptați aici este de a oferi TweenMax suficient timp pentru a muta obiectele în locurile lor de plecare corespunzătoare.
pachet import commands.Command; import commands.display.AddChild; import commands.display.RemoveChild; import commands.events.AddEventListener; import commands.events.RemoveEventListener; import commands.greensock.TweenMaxFrom; import commands.greensock.TweenMaxTo; comenzi de import.ParallelCommand; comenzi de import.SerialCommand; import commands.utils.SetProperties; import commands.utils.Wait; import flash.display.Sprite; importul flash.events.Event; importul flash.events.MouseEvent; import flash.filters.BlurFilter; scenarii de import.Scene; clasa publică Scena1 extinde Scena // parametrii constanți static static const IN_TIME: Number = 0.4; statică statică privată OUT_TIME: Number = 0.2; constr. statică privată DELAY_TIME: Număr = 0.2; constr. statică privată BLUR_AMOUNT: Număr = 20; container privat var: Sprite; privat var ss: Scene1Sprite; privat var blur: BlurFilter; funcția publică Scenă1 (container: Sprite) this.container = container; ss = nou Scene1Sprite (); suprascrie funcția publică createIntroCommand (): Comanda var comanda: Command = new ParallelCommand (0, // "ACEST" nou) TweenMaxFrom (ss.text1_mc, IN_TIME, x: -400 s.text2_mc, IN_TIME, y: -250, întârziere: DELAY_TIME), // "SCENE" nou TweenMaxFrom (ss.text3_mc, IN_TIME, y: 250, întârziere: DELAY_TIME * 2 noul TweenMaxFrom (ss.text4_mc, IN_TIME, x: 400, întârziere: DELAY_TIME * 3), // intro buton nou SerialCommand (0, noul TweenMaxFrom (ss.intro_btn, IN_TIME, y: 250, întârziere: DELAY_TIME * 4 ), noul AddEventListener (ss.intro_btn, MouseEvent.CLICK, replayIntro)), // butonul pentru scenă 2 nou SerialCommand (0, noul TweenMaxFrom (ss.scene2_btn, IN_TIME, y: 250, delay: DELAY_TIME * noul AddEventListener (ss.scene2_btn, MouseEvent.CLICK, gotoScene2)), // mutați scena 1 sprite în centrul containerului nou SetProperties (ss, x: 300, y: 200), // adăugați scena 1 sprite la container // așteptați pentru un cadru pentru a permite lucrurile să fie mutate în locurile potrivite noi SerialCommand (0, new Wait (1 / container r.stage.frameRate), noul AddChild (container, ss))); comanda retur; suprascrie funcția publică createOutroCommand (): Command var blur: BlurFilter = BlurFilter nou (BLUR_AMOUNT, BLUR_AMOUNT, 3); var comanda: Command = new ParallelCommand (0, // elimina obiectele afisate noi SerialCommand (0, // "ACEST" noul TweenMaxTo (ss.text1_mc, OUT_TIME, alpha: 0, blurFilter: noua versiune TweenMaxTo (ss.text3_mc, OUT_TIME, alpha: 0, blurFilter: blur), // "SCENE" noul TweenMaxTo (ss.text4_mc, OUT_TIME, alpha: 0, blurFilter: blur), // introduceți butonul TweenMaxTo (ss.intro_btn, OUT_TIME, alpha: 0, blurFilter: blur TweakMaxTo (ss.scene2_btn, OUT_TIME, alpha: 0, blurFilter: blur), // elimina scena 1 sprite new RemoveChild (container, ss)), // elimina ascultatorii evenimente new RemoveEventListener (ss.intro_btn, MouseEvent.CLICK, replayIntro), noul RemoveEventListener (ss.scene2_btn, MouseEvent.CLICK, gotoScene2)); comanda retur; funcția privată replayIntro (e: Eveniment): void sceneManager.setScene (noul IntroScene (container)); funcția privată gotoScene2 (e: Event): void sceneManager.setScene (nou Scene2 (container));
Clasa Scene2 arată destul de mult ca Scena1; deși textul este modificat:
pachet import commands.Command; import commands.display.AddChild; import commands.display.RemoveChild; import commands.events.AddEventListener; import commands.events.RemoveEventListener; import commands.greensock.TweenMaxFrom; import commands.greensock.TweenMaxTo; comenzi de import.ParallelCommand; comenzi de import.SerialCommand; import commands.utils.SetProperties; import commands.utils.Wait; import flash.display.Sprite; importul flash.events.Event; importul flash.events.MouseEvent; import flash.filters.BlurFilter; scenarii de import.Scene; clasa publică Scena2 extinde Scena // parametrii constanți static static const IN_TIME: Number = 0.4; statică statică privată OUT_TIME: Number = 0.2; constr. statică privată DELAY_TIME: Număr = 0.2; constr. statică privată BLUR_AMOUNT: Număr = 20; container privat var: Sprite; privat var ss: Scene2Sprite; privat var blur: BlurFilter; funcția publică Scene2 (container: Sprite) this.container = container; ss = nou Scene2Sprite (); suprascrie funcția publică createIntroCommand (): comanda var comanda: Command = new ParallelCommand (0, // "... AND" noua TweenMaxFrom (ss.text1_mc, IN_TIME, x: -400 TweenMaxFrom (ss.text2_mc, IN_TIME, y: -250, întârziere: DELAY_TIME), // "SCENE" nou TweenMaxFrom (ss.text3_mc, IN_TIME, y: 2 "noul TweenMaxFrom (ss.text4_mc, IN_TIME, x: 400, întârziere: DELAY_TIME * 3), // intro butonul SerialCommand nou (0, noul TweenMaxFrom (ss.intro_btn, IN_TIME, y: 250, întârziere: DELAY_TIME * 4)), noul AddEventListener (ss.intro_btn, MouseEvent.CLICK, replayIntro)), // butonul pentru scenă 1 nou SerialCommand (0, noul TweenMaxFrom (ss.scene1_btn, IN_TIME, y: 250, delay: DELAY_TIME * ), noua AddEventListener (ss.scene1_btn, MouseEvent.CLICK, gotoScene1)), // mutați scena 2 sprite în centrul containerului nou SetProperties (ss, x: 300, y: 200), // adăugați scena 2 sprite la container // așteptați pentru un cadru pentru a permite lucrurile să fie mutate în locurile potrivite noi SerialCommand (0, new Wait (1 / container.stage.frameRate), noul AddChild (container, ss))); comanda retur; suprascrie funcția publică createOutroCommand (): Command var blur: BlurFilter = BlurFilter nou (BLUR_AMOUNT, BLUR_AMOUNT, 3); var comanda: Command = new ParallelCommand (0, // elimina obiectele afisate noi SerialCommand (0, // "ACEST" noul TweenMaxTo (ss.text1_mc, OUT_TIME, alpha: 0, blurFilter: noi TweenMaxTo (ss.text2_mc, OUT_TIME, alpha: 0, blurFilter: blur), // "SCENE" nou TweenMaxTo (ss.text3_mc, OUT_TIME, alpha: 0, blurFilter: noul TweenMaxTo (ss.text4_mc, OUT_TIME, alpha: 0, blurFilter: blur), // introduceți noul buton TweenMaxTo (ss.intro_btn, OUT_TIME, alpha: 0, blurFilter: blur TweakMaxTo (ss.scene1_btn, OUT_TIME, alpha: 0, blurFilter: blur), // elimina scena 1 sprite new RemoveChild (container, ss)), // elimina ascultatorii evenimentului RemoveEventListener (ss.intro_btn, MouseEvent.CLICK, replayIntro), noul RemoveEventListener (ss.scene1_btn, MouseEvent.CLICK, gotoScene1)); comanda retur; funcția privată replayIntro (e: Eveniment): void sceneManager.setScene (noul IntroScene (container)); funcția privată gotoScene1 (e: Event): void sceneManager.setScene (nou Scene1 (container));
Așa-i, am terminat! Apăsați CTRL + ENTER în Flash IDE pentru a testa filmul și pentru a vedea tranzițiile netede și fără sudură între scene.
În acest tutorial am construit propriile cadre de comandă și de gestionare a scenelor. Am trecut printr-o mulțime de cod, dar merită. Acum că avem aceste cadre la îndemână, gestionarea scenelor se face cu un cod ușor de înțeles și menținut. Fiecare aplicație Flash poate fi împărțită în scene și fiecare scenă constă din comenzi intro și outro. Instrucțiunile sunt încapsulate în comenzi, rezultând un aspect "uniform al codului", care ne permite să gestionăm intro și outro scena într-un mod foarte înalt.
Sper că ți-a plăcut, mulțumesc pentru lectură!
Accentsconagua