Share
Durante questo tutorial estenderemo ulteriormente il framework dei comandi dalla prima parte. Creeremo un framework di gestione delle scene, con codice facilmente comprensibile e gestibile.
Diamo un'occhiata al risultato finale su cui lavoreremo:
Un approccio ragionevole per rompere un'applicazione Flash completa in parti più piccole è gestirlo come scene separate. L'IDE Flash consente di eseguire la gestione delle scene senza scrivere alcun codice, ma affronteremo le cose in modo completamente diverso. Creeremo il nostro framework di gestione delle scene.
Nel nostro framework di gestione delle scene, consideriamo le scene come i più piccoli elementi costitutivi per un'applicazione Flash completa. Ogni scena è composta da un intro comando e un outro comando. Un comando di introduzione inizializza tutto ciò che è necessario per una scena, ad esempio aggiungendo un logo all'elenco di visualizzazione del contenitore sprite. Un comando outro fa esattamente l'opposto, come la rimozione del logo dallo sprite contenitore. È possibile visualizzare la transizione da una scena all'altra come comando outro della prima scena seguita dal comando di introduzione del secondo. In questo modo, possiamo mettere insieme le scene e gestire le loro transizioni molto facilmente.
Dai un'occhiata a questa figura. Una scena è proprio come un pezzo di un puzzle; l'estremità sinistra rappresenta il comando di introduzione e l'estremità destra è il comando di uscita.
Eseguire una transizione dalla scena A alla scena B equivale a collegare i due pezzi insieme. Il comando outro della scena A viene eseguito per primo, il comando di introduzione della scena B viene eseguito successivamente, quindi la transizione della scena è completa.
Fondamentalmente è lo stesso identico concetto per eseguire una transizione dalla scena A alla scena C. Dobbiamo solo mettere insieme i pezzi del puzzle A e C, invece di A e B.
Prima di iniziare a costruire il framework di gestione delle scene, creiamo prima alcune classi di comando che verranno utilizzate in seguito in questo tutorial. È possibile concentrarsi solo sui metodi execute () sovrascritti delle seguenti classi di comando, che è la parte più importante di queste classi.
Senza dubbio, GreenSock Tweening Platform è uno dei migliori framework di interpolazione open source disponibili. Le transizioni di scena di solito coinvolgono molti tweenings e la piattaforma Tweening di GreenSock è sempre stata la mia prima scelta quando si tratta di creare interpolazioni. Incapsuleremo questo framework in classi di comandi per integrarlo con il nostro framework di comando. Scarica la libreria TweenMax e installala.
Useremo i metodi to () e from () della classe TweenMax. La classe TweenMax fornisce un modo per gestire il completamento di un'interpolazione richiamando una funzione a cui fa riferimento la proprietà opzionale "onComplete" nel parametro "vars". Assegneremo il metodo complete () del comando a questa proprietà, quindi il metodo complete () viene richiamato quando l'interpolazione viene eseguita. Di seguito è riportato il codice per i comandi che incapsulano questi due metodi. Crea una nuova directory chiamata "greensock" nella directory "commands" che hai creato nella prima parte di questo tutorial e salva queste classi rispettivamente come TweenMaxTo.as e TweenMaxFrom.as.
pacchetto commands.greensock import com.greensock.TweenMax; comandi di importazione. Comando; // questo comando incapsula il metodo TweenMax.to () public class TweenMaxTo estende Command public var target: Object; durata var pubblica: numero; var var pubblici: Object; funzione pubblica TweenMaxTo (destinazione: Object, durata: Number, vars: Object) this.target = target; this.duration = duration; this.vars = vars; override function protected execute (): void // indica a TweenMax di invocare il metodo complete () del comando quando l'interpolazione viene eseguita vars.onComplete = complete; TweenMax.to (target, duration, vars);
pacchetto commands.greensock import com.greensock.TweenMax; comandi di importazione. Comando; // questo comando incapsula il metodo TweenMax.from () public class TweenMaxFrom estende Command public var target: Object; durata var pubblica: numero; var var pubblici: Object; funzione pubblica TweenMaxFrom (destinazione: Object, durata: Number, vars: Object) this.target = target; this.duration = duration; this.vars = vars; override function protected execute (): void // indica a TweenMax di invocare il metodo complete () del comando quando l'interpolazione viene eseguita vars.onComplete = complete; TweenMax.from (target, duration, vars);
(Assicurati di rileggere la mia introduzione ai comandi se hai bisogno di aggiornare la memoria.)
TweenMaxTo distorce l'oggetto target dalla sua posizione corrente (o sfocatura, alfa o ...) alla nuova posizione (ecc.) Specificata con l'oggetto vars. TweenMaxFrom fa il contrario.
Se hai familiarità con la piattaforma Tweening di GreenSock, potresti anche voler incapsulare le classi TweenLite e TweenNano per soddisfare le tue esigenze.
Come accennato in precedenza, l'introduzione e l'uscita di una scena possono molto probabilmente coinvolgere l'aggiunta di oggetti di visualizzazione a un contenitore di oggetti di visualizzazione e la rimozione degli oggetti dal contenitore. Quindi qui incapsuliamo i comandi addChild () e removeChild () nei comandi.
pacchetto commands.display import commands.Command; import flash.display.DisplayObject; import flash.display.DisplayObjectContainer; // Questo comando incapsula il metodo addChild () public class AddChild extends Command public var container: DisplayObjectContainer; public var displayObject: DisplayObject public function AddChild (container: DisplayObjectContainer, displayObject: DisplayObject) this.container = container; this.displayObject = displayObject; override function protected execute (): void container.addChild (displayObject); completare();
pacchetto commands.display import commands.Command; import flash.display.DisplayObject; import flash.display.DisplayObjectContainer; // Questo comando incapsula il metodo removeChild () public class RemoveChild extends Command public var container: DisplayObjectContainer; public var displayObject: DisplayObject public function RemoveChild (contenitore: DisplayObjectContainer, displayObject: DisplayObject) this.container = container; this.displayObject = displayObject; override function protected execute (): void container.removeChild (displayObject); completare();
Useremo anche i comandi per gestire l'aggiunta e la rimozione dei listener di eventi, quindi incapsuliamo i metodi addEventListener () e removeEventListener ().
pacchetto commands.events import commands.Command; import flash.events.IEventDispatcher; // questo comando incapsula il metodo addEventListener () public class AddEventListener estende Command public var dispatcher: IEventDispatcher; public var type: String; pubblico var listener: Function; funzione pubblica AddEventListener (dispatcher: IEventDispatcher, tipo: String, listener: Function) this.dispatcher = dispatcher; this.type = type; this.listener = listener; override protected function execute (): void dispatcher.addEventListener (type, listener); completare();
pacchetto commands.events import commands.Command; import flash.events.IEventDispatcher; // questo comando incapsula il metodo removeEventListener () public class RemoveEventListener extends Command public var dispatcher: IEventDispatcher; public var type: String; pubblico var listener: Function; public function RemoveEventListener (dispatcher: IEventDispatcher, type: String, listener: Function) this.dispatcher = dispatcher; this.type = type; this.listener = listener; override protected function execute (): void dispatcher.removeEventListener (type, listener); completare();
Infine, avremo bisogno di alcuni comandi di utilità per semplificare le cose. Il comando SetProperties imposta le proprietà di un oggetto dai valori delle proprietà di un altro oggetto:
pacchetto commands.utils import commands.Command; // questo comando imposta le proprietà di un oggetto in modo rapido e conveniente. public classe SetProperties estende Command public var target: Object; proprietà var pubbliche: Object; funzione pubblica SetProperties (target: Object, properties: Object) this.target = target; this.properties = proprietà; override function protected execute (): void for (var key: String in properties) target [chiave] = proprietà [chiave]; completare();
Possiamo usarlo in questo modo:
var setProperties: SetProperties = new SetProperties (target, x: 100, y: 230);
... e imposterà le proprietà x e y dell'oggetto target sui valori specificati.
Il comando Dummy non fa nulla e completa l'esecuzione del comando. Lo scopo di questo comando è quello di fungere da "segnaposto" e deve essere chiarito in seguito:
pacchetto commands.utils import commands.Command; // questo comando semplicemente non fa nulla e si completa con l'esecuzione public class Dummy extends Command public function Dummy () override protected function execute (): void complete ();
Il comando Wait attende una quantità specificata di tempo di ritardo e quindi completa l'esecuzione del comando senza fare nulla:
pacchetto commands.utils import commands.Command; public class Wait extends Command funzione pubblica Wait (delay: Number = 0) super (delay); override function protected execute (): void complete ();
Potreste chiedervi perché avremmo bisogno di un comando che occupi semplicemente il tempo se abbiamo già un parametro di costruzione "delay" nella classe Command di base. A volte ci piacerebbe progettare i costruttori di avere solo parametri che hanno davvero qualcosa a che fare con le specifiche funzionalità del comando, e includendo il tempo di "delay" come un parametro tra loro è tipo di interrompere la "uniformità" in termini di scopi dei parametri. Quindi, invece di scrivere il codice qui sotto:
nuovo SerialCommand (0, new SomeFancyCommand (delay1, fancyParam11, fancyParam12, fancyParam31), new SomeFancyCommand (delay2, fancyParam21, fancyParam22, fancyParam23));
Potremmo scrivere qualcosa come questo:
nuovo SerialCommand (0, new Wait (delay1), new SomeFancyCommand (fancyParam11, fancyParam12, fancyParam31), new Wait (delay2), new SomeFancyCommand (fancyParam21, fancyParam22, fancyParam23));
I parametri "delay" non catturano più inutilmente gli occhi nei costruttori SomeFancyCommand. Ora sono stati spostati sui comandi Wait per rendere le cose più pulite.
Ecco la nostra classe Scene, che rappresenta un singolo "pezzo di puzzle". Ciò che ciascun metodo fa è spiegato nei commenti. Questa classe è praticamente una classe "skeleton", poiché ogni metodo crea un comando fittizio o non fa nulla. Per ottenere cose più succose, questi metodi devono essere ignorati. Crea una nuova directory "scene" nella cartella di origine del tuo progetto per memorizzare queste nuove classi:
scene del pacchetto import commands.Command; import commands.utils.Dummy; // questa classe rappresenta una scena per un'applicazione pubblica completa di Scene Scene // un riferimento al gestore di scena che possiede questa scena var_sceneManager: SceneManager; funzione finale protetta get sceneManager (): SceneManager return _sceneManager; // Crea il comando di introduzione di questa scena public function createIntroCommand (): Command return new Dummy (); // crea il comando outro di questa funzione pubblica di scene createOutroCommand (): Command return new Dummy (); // Gestisci le cose relative alla scena qui quando la scena è impostata public function onSceneSet (): void
Ed ecco la classe SceneManager che gestisce le transizioni di scena, dettagli spiegati anche nei commenti. Si noti che ho aggiunto una "variabile a prova di dummy" per proteggere le transizioni dall'essere interrotte dall'invocazione intempestiva al metodo setScene ().
scene del pacchetto import commands.Command; import flash.events.Event; // questa classe gestisce le transizioni di scena public class SceneManager // un riferimento alla scena corrente private var _currentScene: Scene; // un riferimento alla scena di destinazione di una transizione private var _targetScene: Scene; // Variabile a prova di dummy private var _isInTransition: Boolean = false; public function SceneManager () public function setScene (scene: Scene): void // se una transizione non è terminata, ignora il richiamo del metodo if (_isInTransition) return; _targetScene = scena; // attiva la variabile a prova di prova _isInTransition = true; // controlla se una scena è già assegnata al gestore scene se (_currentScene) // se sì, avvia prima l'outro della scena corrente var outroCommand: Command = _currentScene.createOutroCommand (); // e ascolta l'evento completo del comando outro outroCommand.addEventListener (Event.COMPLETE, onCurrentOutroComplete); outroCommand.start (); else // se non, avvia l'introduzione della scena di destinazione gotoTargetScene (); // invocato quando il comando outro della scena corrente è completo. Funzione privata onCurrentOutroComplete (e: Event): void Command (e.target) .removeEventListener (Event.COMPLETE, onCurrentOutroComplete); gotoTargetScene (); private function gotoTargetScene (): void // imposta il riferimento del gestore di scena della scena di destinazione a questo _targetScene._sceneManager = this; var introCommand: Command = _targetScene.createIntroCommand (); // ascolta l'evento completo del comando di introduzione della scena di destinazione introCommand.addEventListener (Event.COMPLETE, onTargetIntroComplete); introCommand.start (); // invocato quando il comando di introduzione della scena di destinazione è completo. Funzione privata onTargetIntroComplete (e: Event): void Command (e.target) .removeEventListener (Event.COMPLETE, onTargetIntroComplete); // rimuove il riferimento al gestore scene della scena precedente se (_currentScene) _currentScene._sceneManager = null; // imposta la scena target come scena corrente _currentScene = _targetScene; // disattiva la variabile a prova di dummy _isInTransition = false; // e invoca il metodo onSceneSet () _currentScene.onSceneSet ();
Va bene. Tutto è pronto e siamo pronti per partire. È tempo di creare un'applicazione reale con il framework che abbiamo costruito.
Apri l'IDE Flash e crea un nuovo documento Flash. Chiamalo "SceneTransitions" e crea una classe di documenti con lo stesso nome. Inoltre, puoi posizionare uno sfondo sul palco se vuoi.
Crea 4 simboli con il testo e nominali in base all'immagine seguente. In questo esempio, esporta ogni simbolo di ActionScript con un nome di classe uguale al nome del suo simbolo.
Creare simboli e nominarli come mostrato nell'immagine seguente. Inoltre, impagina le loro istanze e assegnale un nome come mostrato. Seleziona tutte le istanze e convertili, come gruppo, in un altro simbolo, denominato "Scene1Sprite". È quindi possibile eliminare Scene1Sprite dallo stage (ma non dalla libreria).
Fai esattamente lo stesso del passaggio precedente, ma questa volta seleziona tutte le istanze e convertile in un simbolo denominato "Scene2Sprite".
La classe del documento è sorprendentemente semplice. Basta creare un gestore di scena e dire al manager di impostare la scena corrente su una scena di introduzione.
pacchetto import flash.display.Sprite; import scene.SceneManager; public class SceneTransitions estende Sprite public function SceneTransitions () var sceneManager: SceneManager = new SceneManager (); sceneManager.setScene (new IntroScene (this));
La scena iniziale che impostiamo per il manager delle scene è una scena introduttiva. Come suggerisce il nome, questa scena è semplicemente un'introduzione alla nostra scena principale (piuttosto che essere la parte introduttiva del "pezzo di puzzle" della nostra scena principale). Il comando di introduzione (creato dal metodo createIntroCommand () di override di questa scena di introduzione sposta le istanze dei simboli al centro dello stage (dal comando SetProperties), li aggiunge al contenitore, li interpone da zero a 100%, e li offusca a zero alfa, uno dopo l'altro. Questo si ottiene collegando tutti i comandi separati insieme a un singolo comando seriale (come dovresti ricordare dalla prima parte).
Quando il comando di introduzione è completo, viene invocato il metodo onSceneSet () e, a questo punto, la proprietà sceneManager è disponibile e il metodo setScene () può essere richiamato per cambiare scena. Nel metodo onSceneSet (), il metodo setScene () del gestore di scena è invocato per passare a Scene1 (una classe che creeremo nel passaggio successivo). Poiché non abbiamo eseguito l'override di createOutroCommand (), il comando outro della scena di introduzione è un comando fittizio, che non esegue nulla.
package import commands.Command; import commands.display.AddChild; import commands.display.RemoveChild; import commands.greensock.TweenMaxFrom; import commands.greensock.TweenMaxTo; import commands.scenes.SetScene; import commands.SerialCommand; import commands.utils.SetProperties; import flash.display.DisplayObject; import flash.display.Sprite; import flash.filters.BlurFilter; scene import.Scene; la classe pubblica IntroScene estende Scene // parametri cost const statici privati ZOOM_IN_TIME: Number = 0.2; private static const HOLD_TIME: Number = 0.3; const statico privato BLUR_OUT_TIME: Number = 0.2; const statico privato BLUR_AMOUNT: Number = 20; contenitore var privato: Sprite; funzione pubblica IntroScene (container: Sprite) this.container = container; sostituisce la funzione pubblica createIntroCommand (): Command var blur: BlurFilter = new BlurFilter (BLUR_AMOUNT, BLUR_AMOUNT, 2); // istanze di simboli var text1: DisplayObject = new IntroText1 (); var text2: DisplayObject = new IntroText2 (); var text3: DisplayObject = new IntroText3 (); var text4: DisplayObject = new IntroText4 (); // questo è il comando seriale che collega le cose insieme var command: Command = new SerialCommand (0, // "THIS" new SetProperties (text1, x: 320, y: 200), new AddChild (container, text1), nuovo TweenMaxFrom (testo1, ZOOM_IN_TIME, scaleX: 0, scaleY: 0), nuovo TweenMaxTo (testo1, BLUR_OUT_TIME, ritardo: HOLD_TIME, alpha: 0, blurFilter: blur), nuovo RemoveChild (contenitore, testo1), // "IS" new SetProperties (testo2, x: 320, y: 200), nuovo AddChild (contenitore, testo2), nuovo TweenMaxFrom (testo2, ZOOM_IN_TIME, scaleX: 0, scaleY: 0), nuovo TweenMaxTo (testo2, BLUR_OUT_TIME, delay: HOLD_TIME, alpha: 0, blurFilter: blur), nuovo RemoveChild (container, text2), // "AN" new SetProperties (text3, x: 320, y: 200), new AddChild (container , text3), nuovo TweenMaxFrom (testo3, ZOOM_IN_TIME, scaleX: 0, scaleY: 0), nuovo TweenMaxTo (testo3, BLUR_OUT_TIME, ritardo: HOLD_TIME, alpha: 0, blurFilter: blur), nuovo RemoveChild (contenitore, testo3 ), // "INTRO" nuove SetProperties (testo4, x: 320, y: 200), nuovo AddChild (contenitore, testo4), nuovo TweenMaxFrom (testo4, ZOOM_IN_TIM E, scaleX: 0, scaleY: 0), nuovo TweenMaxTo (testo4, BLUR_OUT_TIME, delay: HOLD_TIME, alpha: 0, blurFilter: blur), nuovo RemoveChild (container, text4),); comando di ritorno; override public function onSceneSet (): void // quando la scena è impostata, vai direttamente alla scena 1 sceneManager.setScene (new Scene1 (container));
È possibile regolare il valore dei comandi per modificare gli effetti di interpolazione.
Ora diamo un'occhiata alla classe Scene1. I campi di testo sono interpolati in posizione uno per uno; i pulsanti "intro_btn" e "scene2_btn" sono registrati con gli ascoltatori di eventi del mouse-clic dopo essere stati interpolati in posizione, ottenuti concatenando i comandi per l'interpolazione e aggiungendo i listener con un comando seriale.
Un'altra cosa che vale la pena menzionare è il comando AddChild che aggiunge Scene1Sprite al contenitore. È concatenato in serie dopo un comando Wait che attende un frame. Perché la classe TweenMax aggiorna tutti gli oggetti di visualizzazione nel fotogramma successivo dopo la chiamata al metodo TweenMax.from (), a volte potresti vedere un rapido "assaggio" degli oggetti nelle loro posizioni finali, prima che inizi l'interpolazione. Lo scopo del comando Wait qui è di dare a TweenMax il tempo sufficiente per spostare gli oggetti nei loro punti di partenza.
package 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; import commands.ParallelCommand; import commands.SerialCommand; import commands.utils.SetProperties; import commands.utils.Wait; import flash.display.Sprite; import flash.events.Event; import flash.events.MouseEvent; import flash.filters.BlurFilter; scene import.Scene; public class Scene1 estende Scene // cost constant private static const IN_TIME: Number = 0.4; private static const OUT_TIME: Number = 0.2; private static const DELAY_TIME: Number = 0.2; const statico privato BLUR_AMOUNT: Number = 20; contenitore var privato: Sprite; private var ss: Scene1Sprite; blur var privato: BlurFilter; funzione pubblica Scene1 (container: Sprite) this.container = container; ss = new Scene1Sprite (); sostituisce la funzione pubblica createIntroCommand (): Command var command: Command = new ParallelCommand (0, // "THIS" new TweenMaxFrom (ss.text1_mc, IN_TIME, x: -400), // "IS" new TweenMaxFrom ( ss.text2_mc, IN_TIME, y: -250, delay: DELAY_TIME), // "SCENE" new TweenMaxFrom (ss.text3_mc, IN_TIME, y: 250, delay: DELAY_TIME * 2), // "1" nuovo TweenMaxFrom (ss.text4_mc, IN_TIME, x: 400, delay: DELAY_TIME * 3), // pulsante di introduzione nuovo SerialCommand (0, nuovo TweenMaxFrom (ss.intro_btn, IN_TIME, y: 250, delay: DELAY_TIME * 4 ), nuovo AddEventListener (ss.intro_btn, MouseEvent.CLICK, replayIntro)), // scena 2 button new SerialCommand (0, new TweenMaxFrom (ss.scene2_btn, IN_TIME, y: 250, delay: DELAY_TIME * 5), nuovo AddEventListener (ss.scene2_btn, MouseEvent.CLICK, gotoScene2)), // sposta la scena 1 sprite al centro del nuovo contenitore SetProperties (ss, x: 300, y: 200), // aggiungi la scena 1 sprite al container // attendi che un frame permetta di spostare le cose in posti appropriati new SerialCommand (0, new Wait (1 / containe) r.stage.frameRate), new AddChild (container, ss))); comando di ritorno; sostituisce la funzione pubblica createOutroCommand (): Command var blur: BlurFilter = new BlurFilter (BLUR_AMOUNT, BLUR_AMOUNT, 3); var comando: Comando = new ParallelCommand (0, // rimuove oggetti di visualizzazione new SerialCommand (0, // "THIS" new TweenMaxTo (ss.text1_mc, OUT_TIME, alpha: 0, blurFilter: blur), // "IS" nuovo TweenMaxTo (ss.text2_mc, OUT_TIME, alpha: 0, blurFilter: blur), // "SCENE" new TweenMaxTo (ss.text3_mc, OUT_TIME, alpha: 0, blurFilter: blur), // "1" nuovo TweenMaxTo (ss.text4_mc, OUT_TIME, alpha: 0, blurFilter: blur), // pulsante di introduzione nuovo TweenMaxTo (ss.intro_btn, OUT_TIME, alpha: 0, blurFilter: blur), // Pulsante scena 2 nuovo TweenMaxTo (ss.scene2_btn, OUT_TIME, alpha: 0, blurFilter: blur), // rimuove la scena 1 sprite new RemoveChild (container, ss)), // rimuove i listener di eventi new RemoveEventListener (ss.intro_btn, MouseEvent.CLICK, replayIntro), nuovo RemoveEventListener (ss.scene2_btn, MouseEvent.CLICK, gotoScene2)); comando di ritorno; private function replayIntro (e: Event): void sceneManager.setScene (new IntroScene (container)); private function gotoScene2 (e: Event): void sceneManager.setScene (new Scene2 (container));
La classe Scene2 assomiglia molto a Scene1; anche se qualche testo è cambiato:
package 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; import commands.ParallelCommand; import commands.SerialCommand; import commands.utils.SetProperties; import commands.utils.Wait; import flash.display.Sprite; import flash.events.Event; import flash.events.MouseEvent; import flash.filters.BlurFilter; scene import.Scene; public class Scene2 estende Scene // cost constant private static const IN_TIME: Number = 0.4; private static const OUT_TIME: Number = 0.2; private static const DELAY_TIME: Number = 0.2; const statico privato BLUR_AMOUNT: Number = 20; contenitore var privato: Sprite; private var ss: Scene2Sprite; blur var privato: BlurFilter; funzione pubblica Scene2 (container: Sprite) this.container = container; ss = new Scene2Sprite (); sostituisce la funzione pubblica createIntroCommand (): Comando var command: Command = new ParallelCommand (0, // "... AND" new TweenMaxFrom (ss.text1_mc, IN_TIME, x: -400), // "THIS IS" new TweenMaxFrom (ss.text2_mc, IN_TIME, y: -250, delay: DELAY_TIME), // "SCENE" new TweenMaxFrom (ss.text3_mc, IN_TIME, y: 250, delay: DELAY_TIME * 2), // " 2 "nuovo TweenMaxFrom (ss.text4_mc, IN_TIME, x: 400, ritardo: DELAY_TIME * 3), // pulsante di introduzione nuovo SerialCommand (0, nuovo TweenMaxFrom (ss.intro_btn, IN_TIME, y: 250, ritardo: DELAY_TIME * 4), nuovo AddEventListener (ss.intro_btn, MouseEvent.CLICK, replayIntro)), // pulsante scena 1 nuovo SerialCommand (0, nuovo TweenMaxFrom (ss.scene1_btn, IN_TIME, y: 250, delay: DELAY_TIME * 5 ), nuovo AddEventListener (ss.scene1_btn, MouseEvent.CLICK, gotoScene1)), // sposta la scena 2 sprite al centro del nuovo contenitore SetProperties (ss, x: 300, y: 200), // aggiungi il scena 2 sprite al contenitore // attendi che un frame permetta di spostare le cose in posti appropriati nuovo SerialCommand (0, new Wait (1 / container.stage.frameRate), new AddChild (container, ss))); comando di ritorno; sostituisce la funzione pubblica createOutroCommand (): Command var blur: BlurFilter = new BlurFilter (BLUR_AMOUNT, BLUR_AMOUNT, 3); var comando: Comando = new ParallelCommand (0, // rimuove oggetti di visualizzazione new SerialCommand (0, // "THIS" new TweenMaxTo (ss.text1_mc, OUT_TIME, alpha: 0, blurFilter: blur), // "IS" nuovo TweenMaxTo (ss.text2_mc, OUT_TIME, alpha: 0, blurFilter: blur), // "SCENE" new TweenMaxTo (ss.text3_mc, OUT_TIME, alpha: 0, blurFilter: blur), // "2" nuovo TweenMaxTo (ss.text4_mc, OUT_TIME, alpha: 0, blurFilter: blur), // pulsante di introduzione nuovo TweenMaxTo (ss.intro_btn, OUT_TIME, alpha: 0, blurFilter: blur), // Pulsante scena 1 nuovo TweenMaxTo (ss.scene1_btn, OUT_TIME, alpha: 0, blurFilter: blur), // rimuove la scena 1 sprite new RemoveChild (container, ss)), // rimuove i listener di eventi new RemoveEventListener (ss.intro_btn, MouseEvent.CLICK, replayIntro), nuovo RemoveEventListener (ss.scene1_btn, MouseEvent.CLICK, gotoScene1)); comando di ritorno; private function replayIntro (e: Event): void sceneManager.setScene (new IntroScene (container)); private function gotoScene1 (e: Event): void sceneManager.setScene (new Scene1 (container));
Esatto, abbiamo finalmente finito! Premi CTRL + INVIO nell'IDE Flash per testare il film e vedere le transizioni fluide e senza interruzioni tra le scene.
In questo tutorial abbiamo creato i nostri quadri di comando e gestione delle scene. Abbiamo esaminato un sacco di codice, ma ne è valsa la pena. Ora che abbiamo queste strutture a portata di mano, la gestione delle scene avviene con codice facilmente comprensibile e gestibile. Ogni applicazione Flash può essere suddivisa in scene e ogni scena è composta da comandi di introduzione e uscita. Le istruzioni sono incapsulate in comandi, con conseguente "apparenza di codice" uniforme, che ci consente di gestire l'introduzione e l'uscita della scena in un modo molto alto.
Spero che ti sia piaciuto, grazie per la lettura!
Accentsconagua