Share
Durante este tutorial extenderemos más el marco de comandos desde la primera parte. Crearemos un marco de gestión de escena, con código fácilmente comprensible y fácil de mantener..
Echemos un vistazo al resultado final en el que trabajaremos:
Un enfoque razonable para dividir una aplicación Flash completa en partes más pequeñas es gestionarla como escenas separadas. El IDE de Flash le permite realizar la gestión de escenas sin escribir ningún código, pero vamos a abordar las cosas de manera completamente diferente. Crearemos nuestro propio marco de gestión de escena..
En nuestro marco de administración de escenas, consideramos las escenas como los bloques de construcción más pequeños para una aplicación Flash completa. Cada escena se compone de un introducción comando y un outro mando. Un comando de introducción inicializa todo lo que necesita para una escena, como agregar un logotipo a la lista de visualización de su contenedor sprite. Un comando outro hace exactamente lo contrario, como eliminar el logotipo del sprite contenedor. Puede ver la transición de una escena a otra como el comando externo de la primera escena seguido del comando de introducción de la segunda. De esta manera, podemos armar escenas y gestionar sus transiciones con mucha facilidad..
Echa un vistazo a esta figura. Una escena es como una pieza de un rompecabezas; el extremo izquierdo representa el comando de introducción, y el extremo derecho es el comando outro.
Realizar una transición de la escena A a la escena B es como conectar las dos piezas. El comando de salida de la escena A se ejecuta primero, el comando de introducción de la escena B se ejecuta a continuación, luego se completa la transición de la escena.
Es básicamente el mismo concepto para realizar una transición de la escena A a la escena C. Solo tenemos que juntar las piezas de rompecabezas A y C, en lugar de A y B.
Antes de comenzar a crear el marco de administración de escena, primero vamos a crear algunas clases de comandos más que se utilizarán más adelante en este tutorial. Solo puede concentrarse en los métodos de ejecución () anulados de las siguientes clases de comandos, que es la parte más importante de estas clases.
Sin lugar a dudas, GreenSock Tweening Platform es uno de los mejores marcos de interpolación de código abierto que existen. Las transiciones de escena generalmente implican muchas interpolaciones, y GreenSock Tweening Platform siempre ha sido mi primera opción cuando se trata de crear interpolaciones. Vamos a encapsular este marco en clases de comando para integrarlo con nuestro marco de comando. Descargue la librería TweenMax e instálela.
Usaremos los métodos to () y from () de la clase TweenMax. La clase TweenMax proporciona una manera de manejar la finalización de una interpolación invocando una función referenciada por la propiedad opcional "onComplete" en el parámetro "vars". Asignaremos el método complete () del comando a esta propiedad, por lo que se invoca el método complete () cuando se realiza la interpolación. A continuación se muestra el código para los comandos que encapsulan estos dos métodos. Cree un nuevo directorio llamado "greensock" dentro del directorio de "comandos" que creó en la primera parte de este tutorial, y guarde estas clases como TweenMaxTo.as y TweenMaxFrom.as respectivamente.
package commands.greensock import com.greensock.TweenMax; comandos de importación. // este comando encapsula el método TweenMax.to () de la clase pública TweenMaxTo extiende el comando public var target: Object; duración var pública: Número; var vars públicos: objeto; función pública TweenMaxTo (target: Object, duration: Number, vars: Object) this.target = target; esta duración = duración; this.vars = vars; anular la función protegida execute (): void // decirle a TweenMax que invoque el método complete () del comando cuando se realiza la interpolación vars.onComplete = complete; TweenMax.to (objetivo, duración, vars);
package commands.greensock import com.greensock.TweenMax; comandos de importación. // este comando encapsula el método TweenMax.from () de la clase pública TweenMaxFrom extiende el comando public var target: Object; duración var pública: Número; var vars públicos: objeto; función pública TweenMaxFrom (target: Object, duration: Number, vars: Object) this.target = target; esta duración = duración; this.vars = vars; anular la función protegida execute (): void // decirle a TweenMax que invoque el método complete () del comando cuando se realiza la interpolación vars.onComplete = complete; TweenMax.from (objetivo, duración, vars);
(Asegúrese de volver a leer mi introducción a los comandos si necesita actualizar la memoria).
TweenMaxTo interpolará el objeto de destino desde su posición actual (o desenfoque, o alfa, o ...) hasta la nueva posición (etc.) que especifique con el objeto vars. TweenMaxFrom hace lo contrario.
Si está lo suficientemente familiarizado con la GreenSock Tweening Platform, es posible que también desee encapsular las clases TweenLite y TweenNano para satisfacer sus necesidades..
Como se mencionó anteriormente, la introducción y la salida de una escena probablemente impliquen agregar objetos de visualización a un contenedor de objetos de visualización y eliminar los objetos del contenedor. Así que aquí vamos a encapsular los métodos addChild () y removeChild () en comandos.
package command.display comandos de importación.Comando; importar flash.display.DisplayObject; importar flash.display.DisplayObjectContainer; // Este comando encapsula el método addChild () de la clase pública AddChild extiende el comando public var container: DisplayObjectContainer; public var displayObject: DisplayObject public function AddChild (container: DisplayObjectContainer, displayObject: DisplayObject) this.container = container; this.displayObject = displayObject; anular la función protegida execute (): void container.addChild (displayObject); completar();
package command.display comandos de importación.Comando; importar flash.display.DisplayObject; importar flash.display.DisplayObjectContainer; // Este comando encapsula el método removeChild () clase pública RemoveChild extiende Comando public var container: DisplayObjectContainer; public var displayObject: DisplayObject public function RemoveChild (container: DisplayObjectContainer, displayObject: DisplayObject) this.container = container; this.displayObject = displayObject; anular la función protegida execute (): void container.removeChild (displayObject); completar();
También usaremos comandos para manejar la adición y eliminación de escuchas de eventos, por lo que vamos a encapsular los métodos addEventListener () y removeEventListener ().
package command.events import commands.Command; import flash.events.IEventDispatcher; // este comando encapsula el método addEventListener () public class AddEventListener extiende el comando public var dispatcher: IEventDispatcher; tipo de var público: String; oyente de var público: Función; función pública AddEventListener (dispatcher: IEventDispatcher, tipo: String, listener: Function) this.dispatcher = dispatcher; this.type = tipo; this.listener = listener; anular la función protegida execute (): void dispatcher.addEventListener (type, listener); completar();
package command.events import commands.Command; import flash.events.IEventDispatcher; // este comando encapsula el método removeEventListener () public class RemoveEventListener extiende el comando public var dispatcher: IEventDispatcher; tipo de var público: String; oyente de var público: Función; función pública RemoveEventListener (dispatcher: IEventDispatcher, tipo: String, listener: Function) this.dispatcher = dispatcher; this.type = tipo; this.listener = listener; anular la función protegida execute (): void dispatcher.removeEventListener (type, listener); completar();
Finalmente, necesitaremos algunos comandos de utilidad para facilitar las cosas. El comando SetProperties establece las propiedades de un objeto a partir de los valores de propiedad de otro objeto:
package commands.utils import commands.Command; // este comando establece las propiedades de un objeto de manera rápida y conveniente. clase pública SetProperties extiende Comando public var target: Object; propiedades de var público: Objeto; función pública SetProperties (target: Object, properties: Object) this.target = target; this.properties = propiedades; anular la función protegida execute (): void for (var key: String en propiedades) target [key] = properties [key]; completo ();
Podemos usarlo así:
var setProperties: SetProperties = new SetProperties (target, x: 100, y: 230);
... y establecerá las propiedades x e y del objeto de destino en los valores especificados.
El comando Dummy simplemente no hace nada y completa la ejecución del comando. El propósito de este comando es servir como un "marcador de posición" y se aclarará más adelante:
package commands.utils import commands.Command; // este comando simplemente no hace nada y se completa con la ejecución de la clase pública Dummy extended Command public function Dummy () anula la función protegida execute (): void complete ();
El comando Esperar espera una cantidad específica de tiempo de demora y luego completa la ejecución del comando sin hacer nada:
package commands.utils import commands.Command; la clase pública Wait extiende el comando public function Wait (delay: Number = 0) super (delay); anular la función protegida execute (): void complete ();
Podría preguntarse por qué necesitaríamos un comando que simplemente ocupe tiempo si ya tenemos un parámetro de constructor de "retardo" en la clase de comando base. A veces nos gustaría diseñar constructores que solo tengan parámetros que realmente tengan algo que ver con la funcionalidad específica del comando, e incluir el tiempo de "demora" como un parámetro entre ellos es una especie de interrupción de la "uniformidad" en términos de propósitos de parámetros. Así que en lugar de escribir el siguiente código:
nuevo SerialCommand (0, nuevo SomeFancyCommand (delay1, fancyParam11, fancyParam12, fancyParam31), nuevo SomeFancyCommand (delay2, fancyParam21, fancyParam22, fancyParam23));
Podríamos escribir algo como esto:
nuevo SerialCommand (0, new Wait (delay1), nuevo SomeFancyCommand (fancyParam11, fancyParam12, fancyParam31), new Wait (delay2), nuevo SomeFancyCommand (fancyParam21, fancyParam22));
Los parámetros de "retraso" ya no atraen innecesariamente sus ojos en los constructores SomeFancyCommand. Ahora se han movido a los comandos Esperar para limpiar las cosas.
Aquí está nuestra clase de escena, que representa una sola "pieza de rompecabezas". Lo que hace cada método se explica en los comentarios. Esta clase es prácticamente una clase "esquelética", ya que cada método crea un comando ficticio o no hace nada. Para hacer las cosas más jugosas, estos métodos deben ser anulados. Cree un nuevo directorio de "escenas" en la carpeta de origen de su proyecto para almacenar estas nuevas clases:
paquete de escenas comandos de importación. Comando; importar los comandos.utils.Dummy; // esta clase representa una escena para una aplicación Flash completa clase pública Escena // una referencia al administrador de escena que posee esta escena interna var _sceneManager: SceneManager; función final protegida obtener sceneManager (): SceneManager return _sceneManager; // crea el comando de introducción de esta escena public function createIntroCommand (): Command return new Dummy (); // crea el comando externo de esta escena public function createOutroCommand (): Command return new Dummy (); // maneja las cosas relacionadas con la escena aquí cuando la escena está configurada como función pública onSceneSet (): void
Y aquí está la clase SceneManager que maneja las transiciones de escena, los detalles también se explican en los comentarios. Tenga en cuenta que he agregado una "variable de prueba ficticia" para evitar que las transiciones se rompan por invocación inoportuna al método setScene ().
paquete de escenas comandos de importación. Comando; import flash.events.Event; // esta clase maneja transiciones de escena clase pública SceneManager // una referencia a la escena actual var _currentScene: Scene; // una referencia a la escena objetivo de una transición privada var _targetScene: Scene; // variable privada dummy-proof var _isInTransition: Boolean = false; función pública SceneManager () función pública setScene (escena: escena): void // si una transición no ha finalizado, ignore la invocación del método si (_isInTransition) devuelve; _targetScene = escena; // enciende la variable de prueba ficticia _isInTransition = true; // compruebe si ya hay una escena asignada al gestor de escenas si (_currentScene) // en caso afirmativo, inicie primero la salida de la escena actual var outroCommand: Command = _currentScene.createOutroCommand (); // y escuchar el evento completo del comando outroCommand.addEventListener (Event.COMPLETE, onCurrentOutroComplete); outroCommand.start (); else // si no, inicie la introducción de la escena de destino gotoTargetScene (); // invocado cuando el comando externo de la escena actual está completo. Función privada onCurrentOutroComplete (e: Event): void Command (e.target) .removeEventListener (Event.COMPLETE, onCurrentOutroComplete); gotoTargetScene (); función privada gotoTargetScene (): void // establece la referencia del administrador de la escena de la escena objetivo a este _targetScene._sceneManager = this; var introCommand: Command = _targetScene.createIntroCommand (); // escuchar el evento completo del comando de introducción de la escena de destino introCommand.addEventListener (Event.COMPLETE, onTargetIntroComplete); introCommand.start (); // se invoca cuando el comando de introducción de la escena de destino está completo. Función privada enTargetIntroComplete (e: Event): void Command (e.target) .removeEventListener (Event.COMPLETE, onTargetIntroComplete); // eliminar la referencia del administrador de escena de la escena anterior si (_currentScene) _currentScene._sceneManager = null; // establece la escena objetivo como la escena actual _currentScene = _targetScene; // desactiva la variable de prueba falsa _isInTransition = false; // e invocar el método onSceneSet () _currentScene.onSceneSet ();
Bueno. Todo está listo y estamos listos para irnos. Es hora de crear una aplicación real con el marco que hemos construido.
Abra el IDE de Flash y cree un nuevo documento de Flash. Denomínelo "SceneTransitions" y cree una clase de documento con el mismo nombre. Además, puedes colocar un fondo en el escenario si quieres..
Cree 4 símbolos con texto y asígnele un nombre de acuerdo con la siguiente imagen. En este ejemplo, exporte todos los símbolos para ActionScript con un nombre de clase que sea igual al nombre de su símbolo.
Crea símbolos y nómbralos como se muestra en la siguiente imagen. Además, diseñe sus instancias y nómbrelas como se muestra. Seleccione todas las instancias y conviértalas, como grupo, a otro símbolo, llamado "Scene1Sprite". A continuación, puede eliminar Scene1Sprite de la etapa (pero no de la biblioteca).
Haga exactamente lo mismo que en el paso anterior, pero esta vez seleccione todas las instancias y conviértalas en un símbolo llamado "Scene2Sprite".
La clase de documentos es sorprendentemente simple. Simplemente crea un administrador de escena y dile al administrador que establezca la escena actual en una escena de introducción.
paquete import flash.display.Sprite; escenas de importación.SceneManager; clase pública SceneTransitions extiende Sprite función pública SceneTransitions () var sceneManager: SceneManager = new SceneManager (); sceneManager.setScene (nuevo IntroScene (este));
La escena inicial que configuramos para el administrador de escena es una escena de introducción. Como su nombre lo indica, esta escena es simplemente una introducción a nuestra escena principal (en lugar de ser la parte de introducción de la "pieza de rompecabezas" de nuestra escena principal). El comando de introducción (creado a partir del método anular createIntroCommand ()) de esta escena de introducción mueve las instancias de los símbolos al centro del escenario (mediante el comando SetProperties), los agrega al contenedor, los ajusta desde la escala cero a la escala del 100%. y los difumina a cero alfa, uno tras otro. Esto se logra al vincular todos los comandos separados junto con un solo comando en serie (como debe recordar de la Parte Uno).
Cuando se completa el comando de introducción, se invoca el método onSceneSet (), y en este punto la propiedad sceneManager está disponible, y su método setScene () se puede invocar para cambiar de escena. En el método onSceneSet (), se invoca el método setScene () del administrador de escena para cambiar a Scene1 (una clase que crearemos en el siguiente paso). Como no anulamos el comando createOutroCommand (), el comando de salida de la escena de introducción es un comando ficticio, que no hace nada..
paquete comandos de importación. Comando; importar comandos.display.AddChild; importar comandos.display.RemoveChild; importar comandos.greensock.TweenMaxFrom; importar comandos.greensock.TweenMaxTo; importar comandos.scenes.SetScene; comandos de importación.SerialCommand; importar comandos.utils.SetProperties; importar flash.display.DisplayObject; importar flash.display.Sprite; importar flash.filters.BlurFilter; escenas de importación. la clase pública IntroScene extiende la escena // parámetros constantes privados const. estática ZOOM_IN_TIME: Número = 0.2; const estática privada HOLD_TIME: Número = 0.3; const estática privada BLUR_OUT_TIME: Número = 0.2; constata estática privada BLUR_AMOUNT: Número = 20; contenedor var privado: Sprite; función pública IntroScene (contenedor: Sprite) this.container = container; anular la función pública createIntroCommand (): Comando var blur: BlurFilter = new BlurFilter (BLUR_AMOUNT, BLUR_AMOUNT, 2); // instancias de símbolos var text1: DisplayObject = new IntroText1 (); var text2: DisplayObject = new IntroText2 (); var text3: DisplayObject = new IntroText3 (); var text4: DisplayObject = new IntroText4 (); // este es el comando serial que une las cosas var command: Command = new SerialCommand (0, // "THIS" new SetProperties (text1, x: 320, y: 200), nuevo AddChild (container, text1), nuevo TweenMaxFrom (text1, ZOOM_IN_TIME, scaleX: 0, scaleY: 0), nuevo TweenMaxTo (text1, BLUR_OUT_TIME, delay: HOLD_TIME, alpha: 0, blurFilter: blur), nuevo RemoveChild (container, text1), // "IS" nuevas SetProperties (texto2, x: 320, y: 200), nuevo AddChild (contenedor, texto2), nuevo TweenMaxFrom (texto2, ZOOM_IN_TIME, scaleX: 0, scaleY: 0), nuevo TweenMaxTo (texto2, BLUR_OUT_TIME, delay: HOLD_TIME, alpha: 0, blurFilter: blur), nuevo RemoveChild (container, text2), // "AN" new SetProperties (text3, x: 320, y: 200), nuevo AddChild (container , text3), nuevo TweenMaxFrom (text3, ZOOM_IN_TIME, scaleX: 0, scaleY: 0), nuevo TweenMaxTo (text3, BLUR_OUT_TIME, delay: HOLD_TIME, alpha: 0, blurFilter: blur), nuevo RemoveChild (container, text3) ), // "INTRO" nuevas SetProperties (text4, x: 320, y: 200), nuevo AddChild (container, text4), nuevo TweenMaxFrom (text4, ZOOM_IN_TIM E, scaleX: 0, scaleY: 0), nuevo TweenMaxTo (text4, BLUR_OUT_TIME, delay: HOLD_TIME, alpha: 0, blurFilter: blur), nuevo RemoveChild (container, text4),); comando de retorno anular la función pública onSceneSet (): void // cuando se establece la escena, ir directamente a la escena 1 sceneManager.setScene (nueva Scene1 (contenedor));
Puede ajustar el valor de las constantes para alterar los efectos de interpolación.
Ahora veamos la clase Scene1. Los campos de texto se interpolan en la posición uno por uno; los botones "intro_btn" y "scene2_btn" se registran con los escuchas de eventos de clic de ratón después de haber sido interpolados en posición, logrados al encadenar los comandos para interpolar y agregar escuchas con un comando en serie.
Otra cosa que vale la pena mencionar es el comando AddChild que agrega Scene1Sprite al contenedor. Se concatena en serie después de un comando Esperar que espera un fotograma. Porque la clase TweenMax actualiza todos los objetos de visualización en el siguiente cuadro después En la llamada al método TweenMax.from (), es posible que a veces veas un vistazo rápido de los objetos en sus lugares finales, antes de que comience la interpolación. El propósito del comando Esperar aquí es darle a TweenMax el tiempo suficiente para mover los objetos a sus lugares de inicio apropiados.
paquete comandos de importación. Comando; importar comandos.display.AddChild; importar comandos.display.RemoveChild; importar commands.events.AddEventListener; importar command.events.RemoveEventListener; importar comandos.greensock.TweenMaxFrom; importar comandos.greensock.TweenMaxTo; comandos de import.ParallelCommand; comandos de importación.SerialCommand; importar comandos.utils.SetProperties; importar comandos.utils.Wait; importar flash.display.Sprite; import flash.events.Event; import flash.events.MouseEvent; importar flash.filters.BlurFilter; escenas de importación. la clase pública Scene1 extiende la escena // parámetros constantes private static const IN_TIME: Number = 0.4; const estática privada OUT_TIME: Número = 0.2; constata estática privada DELAY_TIME: Número = 0.2; constata estática privada BLUR_AMOUNT: Número = 20; contenedor var privado: Sprite; vars privadas: Scene1Sprite; desenfoque de var privado: BlurFilter; función pública Scene1 (contenedor: Sprite) this.container = container; ss = nuevo Scene1Sprite (); anular la función pública 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, retraso: DELAY_TIME), // "SCENE" nuevo TweenMaxFrom (ss.text3_mc, IN_TIME, y: 250, retraso: DELAY_TIME * 2), // "1" nuevo TweenMaxFrom (ss.text4_mc, IN_TIME, x: 400, retraso: DELAY_TIME * 3), // botón de introducción nuevo SerialCommand (0, nuevo TweenMaxFrom (ss.intro_btn, IN_TIME, y: 250, retraso: DELAY_TIME * 4 ), nuevo AddEventListener (ss.intro_btn, MouseEvent.CLICK, replayIntro)) // botón de la escena 2 nuevo SerialCommand (0, nuevo TweenMaxFrom (ss.scene2_btn, IN_TIME, y: 250, delay: DELAY_TIME * 5), new AddEventListener (ss.scene2_btn, MouseEvent.CLICK, gotoScene2)), // mueve el sprite de escena 1 al centro del contenedor new SetProperties (ss, x: 300, y: 200), // agrega la escena 1 sprite al contenedor // espere un fotograma para permitir que las cosas se muevan a lugares apropiados nuevo SerialCommand (0, new Wait (1 / containe r.stage.frameRate), nuevo AddChild (container, ss))); comando de retorno anular la función pública createOutroCommand (): Comando var blur: BlurFilter = new BlurFilter (BLUR_AMOUNT, BLUR_AMOUNT, 3); var comando: Comando = nuevo ParallelCommand (0, // eliminar objetos de visualización nuevo SerialCommand (0, // "ESTE" nuevo TweenMaxTo (ss.text1_mc, OUT_TIME, alpha: 0, blurFilter: blur), // "IS" nuevo TweenMaxTo (ss.text2_mc, OUT_TIME, alpha: 0, blurFilter: blur), // "SCENE" nuevo TweenMaxTo (ss.text3_mc, OUT_TIME, alpha: 0, blurFilter: blur), // "1" nuevo TweenMaxTo (ss.text4_mc, OUT_TIME, alpha: 0, blurFilter: blur), // intro button new TweenMaxTo (ss.intro_btn, OUT_TIME, alpha: 0, blurFilter: blur), // scene 2 button new TweenMaxTo (ss.scene2_btn, OUT_TIME, alpha: 0, blurFilter: blur), // eliminar la escena 1 sprite nuevo RemoveChild (container, ss), // eliminar los escuchas de eventos nuevo RemoveEventListener (ss.intro_btn, MouseEvent.CLICK, replayIntro), nuevo RemoveEventListener (ss.scene2_btn, MouseEvent.CLICK, gotoScene2)); comando de retorno función privada replayIntro (e: Evento): void sceneManager.setScene (nuevo IntroScene (contenedor)); función privada gotoScene2 (e: Evento): void sceneManager.setScene (nueva Scene2 (contenedor));
La clase Scene2 se parece mucho a Scene1; aunque se cambia algún texto:
paquete comandos de importación. Comando; importar comandos.display.AddChild; importar comandos.display.RemoveChild; importar commands.events.AddEventListener; importar command.events.RemoveEventListener; importar comandos.greensock.TweenMaxFrom; importar comandos.greensock.TweenMaxTo; comandos de import.ParallelCommand; comandos de importación.SerialCommand; importar comandos.utils.SetProperties; importar comandos.utils.Wait; importar flash.display.Sprite; import flash.events.Event; import flash.events.MouseEvent; importar flash.filters.BlurFilter; escenas de importación. la clase pública Scene2 extiende la escena // parámetros constantes private static const IN_TIME: Number = 0.4; const estática privada OUT_TIME: Número = 0.2; constata estática privada DELAY_TIME: Número = 0.2; constata estática privada BLUR_AMOUNT: Número = 20; contenedor var privado: Sprite; vars privadas: Scene2Sprite; desenfoque de var privado: BlurFilter; función pública Scene2 (contenedor: Sprite) this.container = container; ss = nuevo Scene2Sprite (); anular la función pública createIntroCommand (): Command var command: Command = new ParallelCommand (0, // "AND AND new new TweenMaxFrom (ss.text1_mc, IN_TIME, x: -400), //" THIS IS "new TweenMaxFrom (ss.text2_mc, IN_TIME, y: -250, retraso: DELAY_TIME), // "SCENE" nuevo TweenMaxFrom (ss.text3_mc, IN_TIME, y: 250, retraso: DELAY_TIME * 2)), // " 2 "nuevo TweenMaxFrom (ss.text4_mc, IN_TIME, x: 400, retraso: DELAY_TIME * 3), // botón de introducción nuevo SerialCommand (0, nuevo TweenMaxFrom (ss.intro_btn, IN_TIME, y: 250, retraso: DELAY_TIME * 4), nuevo AddEventListener (ss.intro_btn, MouseEvent.CLICK, replayIntro)) // botón de la escena 1 nuevo SerialCommand (0, nuevo TweenMaxFrom (ss.scene1_btn, IN_TIME, y: 250, delay: DELAY_TIME * 5 ), nuevo AddEventListener (ss.scene1_btn, MouseEvent.CLICK, gotoScene1)), // mover el sprite de la escena 2 al centro del nuevo contenedor SetProperties (ss, x: 300, y: 200), // agregar el escena 2 sprite al contenedor // espere un fotograma para permitir que las cosas se muevan a lugares apropiados nuevo SerialCommand (0, nuevo Wait (1 / container.stage.frameRate), nuevo AddChild (container, ss))); comando de retorno anular la función pública createOutroCommand (): Comando var blur: BlurFilter = new BlurFilter (BLUR_AMOUNT, BLUR_AMOUNT, 3); var comando: Comando = nuevo ParallelCommand (0, // eliminar objetos de visualización nuevo SerialCommand (0, // "ESTE" nuevo TweenMaxTo (ss.text1_mc, OUT_TIME, alpha: 0, blurFilter: blur), // "IS" nuevo TweenMaxTo (ss.text2_mc, OUT_TIME, alpha: 0, blurFilter: blur), // "SCENE" nuevo TweenMaxTo (ss.text3_mc, OUT_TIME, alpha: 0, blurFilter: blur), // "2" nuevo TweenMaxTo (ss.text4_mc, OUT_TIME, alpha: 0, blurFilter: blur), // intro button new TweenMaxTo (ss.intro_btn, OUT_TIME, alpha: 0, blurFilter: blur), // scene 1 button new TweenMaxTo (ss.scene1_btn, OUT_TIME, alpha: 0, blurFilter: blur), // eliminar la escena 1 sprite nuevo RemoveChild (container, ss), // eliminar los escuchas de eventos nuevo RemoveEventListener (ss.intro_btn, MouseEvent.CLICK, replayIntro), nuevo RemoveEventListener (ss.scene1_btn, MouseEvent.CLICK, gotoScene1)); comando de retorno función privada replayIntro (e: Evento): void sceneManager.setScene (nuevo IntroScene (contenedor)); función privada gotoScene1 (e: Evento): void sceneManager.setScene (nueva Scene1 (contenedor));
Así es, ¡por fin hemos terminado! Presione CTRL + ENTRAR en el IDE de Flash para probar la película y ver las transiciones suaves y sin problemas entre escenas.
En este tutorial hemos creado nuestros propios marcos de gestión de comandos y escenas. Hemos revisado un montón de códigos, pero vale la pena. Ahora que tenemos estos marcos a la mano, la gestión de escenas se realiza con un código fácil de entender y mantener. Cada aplicación Flash se puede dividir en escenas, y cada escena consta de comandos de introducción y salida. Las instrucciones se encapsulan en comandos, lo que da como resultado una "apariencia de código" uniforme, lo que nos permite administrar la introducción y salida de la escena de una manera muy alta..
Espero que lo hayas disfrutado, gracias por leer.!
Accentsconagua