Share
Tijdens deze tutorial zullen we het command framework uit het eerste deel verder uitbreiden. We zullen een scènebeheerkader creëren met eenvoudig te begrijpen en te onderhouden code.
Laten we eens kijken naar het eindresultaat waar we naartoe zullen werken:
Een redelijke mogelijkheid om een complete Flash-toepassing in kleinere stukjes te breken, is om deze als afzonderlijke scènes te beheren. Met de Flash IDE kun je scènebeheer uitvoeren zonder code te schrijven, maar we gaan de dingen heel anders benaderen. We zullen ons eigen scènebeheersingskader creëren.
In ons scènebeheerkader beschouwen we scènes als de kleinste bouwstenen voor een complete Flash-toepassing. Elke scène bestaat uit een intro commando en een outro commando. Een intro-opdracht initialiseert alles wat u nodig hebt voor een scène, zoals het toevoegen van een logo aan de weergavelijst van uw containersprite. Een outro-commando doet precies het tegenovergestelde, zoals het verwijderen van het logo uit de containersprite. Je kunt de overgang van de ene scène naar de andere zien als de outro-opdracht van de eerste scène, gevolgd door de intro-opdracht van de tweede. Op deze manier kunnen we scènes samenvoegen en hun overgangen heel gemakkelijk beheren.
Bekijk deze figuur eens. Eén scène is net een stukje van een puzzel; het linker uiteinde vertegenwoordigt het intro commando, en het rechter uiteinde is het outro commando.
Het uitvoeren van een overgang van scène A naar scène B is hetzelfde als het samen verbinden van de twee delen. De outro-opdracht van scène A wordt eerst uitgevoerd, de intro-opdracht van scène B wordt vervolgens uitgevoerd en vervolgens is de scèneovergang voltooid.
Het is eigenlijk exact hetzelfde concept om een overgang van scène A naar scène C uit te voeren. We moeten alleen puzzelstukjes A en C samenvoegen, in plaats van A en B.
Voordat we beginnen met het bouwen van het scenariobeheerraamwerk, moeten we eerst wat meer opdrachtklassen maken die later in deze zelfstudie worden gebruikt. U kunt zich alleen richten op de overschreven execute () -methoden van de volgende opdrachtklassen, wat het belangrijkste deel van deze klassen is.
GreenSock Tweening Platform is ongetwijfeld een van de beste open source tweening-frameworks die er zijn. Bij scenische overgangen zijn meestal veel tweenings betrokken en GreenSock Tweening Platform is altijd mijn eerste keus geweest bij het maken van tweens. We gaan dit raamwerk inkapselen in commandoklassen om het te integreren met ons command framework. Download de TweenMax-bibliotheek en installeer deze.
We zullen de methoden to () en from () uit de TweenMax-klasse gebruiken. De klasse TweenMax biedt een manier om de voltooiing van een tween af te handelen door een functie aan te roepen waarnaar wordt verwezen door de optionele eigenschap "onComplete" in de parameter "vars". We zullen de opdracht complete () aan deze eigenschap toewijzen, dus de methode complete () wordt aangeroepen wanneer de tween is voltooid. Hieronder staat de code voor de opdrachten die deze twee methoden inkapselen. Maak een nieuwe map met de naam "greensock" in de map "commands" die je in het eerste deel van deze tutorial hebt gemaakt en sla deze klassen op als TweenMaxTo.as en TweenMaxFrom.as.
pakket commands.greensock import com.greensock.TweenMax; importeer commando's. Command; // deze opdracht bevat de TweenMax.to () -methode public class TweenMaxTo extends Command public var target: Object; public var duration: Number; public var vars: Object; openbare functie TweenMaxTo (doel: Object, duration: Number, vars: Object) this.target = target; this.duration = duur; this.vars = vars; override protected function execute (): void // vertel TweenMax om de opdracht complete () methode aan te roepen wanneer de tweening is voltooid vars.onComplete = voltooid; TweenMax.to (doel, duur, vars);
pakket commands.greensock import com.greensock.TweenMax; importeer commando's. Command; // deze opdracht bevat de methode TweenMax.from () public class TweenMaxFrom extends Command public var target: Object; public var duration: Number; public var vars: Object; public function TweenMaxFrom (target: Object, duration: Number, vars: Object) this.target = target; this.duration = duur; this.vars = vars; override protected function execute (): void // vertel TweenMax om de opdracht complete () methode aan te roepen wanneer de tweening is voltooid vars.onComplete = voltooid; TweenMax.van (doel, duur, vars);
(Zorg ervoor dat u mijn inleiding tot de opdrachten herleest als u uw geheugen moet vernieuwen.)
TweenMaxTo tweent het doelobject van de huidige positie (of vervaging, of alpha, of ...) naar de nieuwe positie (etc) die u opgeeft met het vars-object. TweenMaxFrom doet het tegenovergestelde.
Als u voldoende bekend bent met het GreenSock Tweening Platform, wilt u misschien ook de TweenLite- en TweenNano-klassen inkapselen om aan uw behoeften te voldoen.
Zoals eerder vermeld, kunnen de intro en outro van een scène zeer waarschijnlijk betrekking hebben op het toevoegen van weergaveobjecten aan een weergaveobjectcontainer en het verwijderen van de objecten uit de container. Laten we hier de methoden addChild () en removeChild () samenvoegen in opdrachten.
package commands.display import commands.Command; import flash.display.DisplayObject; import flash.display.DisplayObjectContainer; // Deze opdracht bevat de addChild () -methode public class AddChild extends Command openbare var-container: DisplayObjectContainer; public var displayObject: DisplayObject public function AddChild (container: DisplayObjectContainer, displayObject: DisplayObject) this.container = container; this.displayObject = displayObject; override protected function execute (): void container.addChild (displayObject); compleet();
package commands.display import commands.Command; import flash.display.DisplayObject; import flash.display.DisplayObjectContainer; // Deze opdracht bevat de methode removeChild () public class RemoveChild extends Command openbare var-container: DisplayObjectContainer; public var displayObject: DisplayObject public function RemoveChild (container: DisplayObjectContainer, displayObject: DisplayObject) this.container = container; this.displayObject = displayObject; override protected function execute (): void container.removeChild (displayObject); compleet();
We zullen ook opdrachten gebruiken voor het toevoegen en verwijderen van gebeurtenislisteners, dus laten we de methoden addEventListener () en removeEventListener () samenvatten.
pakket commands.events import commands.Command; import flash.events.IEventDispatcher; // deze opdracht bevat de methode addEventListener () public class AddEventListener extends Command public var dispatcher: IEventDispatcher; public var type: String; public var listener: functie; public function AddEventListener (dispatcher: IEventDispatcher, type: String, listener: Function) this.dispatcher = dispatcher; this.type = type; this.listener = luisteraar; override protected function execute (): void dispatcher.addEventListener (type, luisteraar); compleet();
pakket commands.events import commands.Command; import flash.events.IEventDispatcher; // deze opdracht bevat de methode removeEventListener () public class RemoveEventListener breidt opdracht uit public var dispatcher: IEventDispatcher; public var type: String; public var listener: functie; openbare functie RemoveEventListener (dispatcher: IEventDispatcher, type: String, listener: Function) this.dispatcher = dispatcher; this.type = type; this.listener = luisteraar; override protected function execute (): void dispatcher.removeEventListener (type, luisteraar); compleet();
Ten slotte hebben we enkele hulpprogrammaopdrachten nodig om dingen eenvoudiger te maken. Met de opdracht SetProperties worden de eigenschappen van een object uit de eigenschapswaarden van een ander object ingesteld:
pakket commands.utils import commands.Command; // deze opdracht stelt de eigenschappen van een object snel en gemakkelijk in. public class SetProperties extends Command public var target: Object; public var properties: Object; openbare functie SetProperties (doel: Object, eigenschappen: Object) this.target = target; this.properties = eigenschappen; override protected function execute (): void for (var key: String in properties) target [key] = properties [key]; compleet();
We kunnen het zo gebruiken:
var setProperties: SetProperties = nieuwe SetProperties (doel, x: 100, y: 230);
... en stelt de x- en y-eigenschappen van het doelobject in op de opgegeven waarden.
De Dummy-opdracht doet gewoon niets en voltooit de uitvoering van de opdracht. Het doel van deze opdracht is om te dienen als een "tijdelijke aanduiding" en later duidelijk te worden:
pakket commands.utils import commands.Command; // deze opdracht doet gewoon niets en voltooit zichzelf na uitvoering publieke klasse Dummy extends Command publieke functie Dummy () override protected function execute (): void complete ();
De opdracht Wait wacht een opgegeven hoeveelheid vertragingstijd en voltooit de uitvoering van de opdracht zonder iets te doen:
pakket commands.utils import commands.Command; public class Wait extends Command public function Wait (delay: Number = 0) super (delay); override protected function execute (): void complete ();
Je vraagt je misschien af waarom we een opdracht nodig hebben die eenvoudigweg tijd in beslag neemt als we al een "vertraging" -constructorfactor hebben in de basis-commandoklasse. Soms willen we constructeurs ontwerpen om alleen parameters te hebben die echt iets te maken hebben met de specifieke functionaliteit van het commando, en inclusief de "delay" -tijd als een van de parameters die de "uniformiteit" in termen van parameter-doeleinden onderbreekt. Dus in plaats van de code hieronder te schrijven:
nieuwe SerialCommand (0, nieuw SomeFancyCommand (delay1, fancyParam11, fancyParam12, fancyParam31), nieuw SomeFancyCommand (delay2, fancyParam21, fancyParam22, fancyParam23));
We kunnen zoiets als dit schrijven:
nieuwe SerialCommand (0, nieuwe Wait (delay1), nieuwe SomeFancyCommand (fancyParam11, fancyParam12, fancyParam31), nieuwe Wait (delay2), nieuwe SomeFancyCommand (fancyParam21, fancyParam22, fancyParam23));
De "delay" -parameters vallen niet langer onnodig in de gaten in de SomeFancyCommand-constructors. Ze zijn nu verplaatst naar de wachtcommando's om dingen schoner te maken.
Dit is onze scèneklasse, die een enkel "puzzelstukje" vertegenwoordigt. Wat elke methode doet, wordt uitgelegd in de opmerkingen. Deze klasse is zo'n beetje een "skelet" -klasse, omdat elke methode een dummy-commando maakt of niets doet. Om dingen sappiger te maken, moeten deze methoden worden opgeheven. Maak een nieuwe map "scènes" in de bronmap van uw project om deze nieuwe klassen op te slaan:
pakket scènes import commands.Command; import commands.utils.Dummy; // deze klasse vertegenwoordigt een scène voor een complete Flash-toepassing public class Scene // een verwijzing naar de scènebeheerder die deze scène bezit interne var _sceneManager: SceneManager; beschermde laatste functie krijgt sceneManager (): SceneManager return _sceneManager; // maakt de intro-opdracht van deze scène openbare functie createIntroCommand (): Command return new Dummy (); // maakt de outro-opdracht van deze scène openbare functie createOutroCommand (): Command return new Dummy (); // behandel scène-gerelateerde dingen hier wanneer de scène is ingesteld op public function onSceneSet (): void
En hier is de SceneManager-klasse die scènetransities verwerkt, details die ook in de opmerkingen worden uitgelegd. Merk op dat ik een "dummy-proof variabele" heb toegevoegd om te voorkomen dat overgangen worden verbroken door een niet-aanroepende aanroep naar de methode setScene ().
pakket scènes import commands.Command; import flash.events.Event; // deze klasse verwerkt scène-overgangen public class SceneManager // een verwijzing naar de huidige scene private var _currentScene: Scene; // een verwijzing naar de doelscène van een transitie private var _targetScene: Scene; // dummy-proof variabele private var _isInTransition: Boolean = false; openbare functie SceneManager () openbare functie setScene (scène: scène): void // als een overgang niet is voltooid, negeert u de methode-aanroep als (_isInTransition) wordt geretourneerd; _targetScene = scène; // schakel de dummy-proof variabele _isInTransition = true in; // controleer of een scène al is toegewezen aan de scènebeheerder (_currentScene) // if yes, start de outro van de huidige scène eerst var outroCommand: Command = _currentScene.createOutroCommand (); // en luister naar de volledige gebeurtenis van de outro-opdracht outroCommand.addEventListener (Event.COMPLETE, onCurrentOutroComplete); outroCommand.start (); else // if not, start de intro van de doelscène gotoTargetScene (); // wordt aangeroepen wanneer de outro-opdracht van de huidige scène volledige privéfunctie onCurrentOutroComplete is (e: Event): void Command (e.target) .removeEventListener (Event.COMPLETE, onCurrentOutroComplete); gotoTargetScene (); private function gotoTargetScene (): void // zet de scènemanagerreferentie van de doelscène op deze _targetScene._sceneManager = this; var introCommand: Command = _targetScene.createIntroCommand (); // luister naar de complete gebeurtenis van de intro-opdracht van de doelscene introCommand.addEventListener (Event.COMPLETE, onTargetIntroComplete); introCommand.start (); // wordt aangeroepen wanneer de intro-opdracht van de doelscène volledige persoonlijke functie onTargetIntroComplete (e: Event) is: void Command (e.target) .removeEventListener (Event.COMPLETE, onTargetIntroComplete); // verwijder de scènemanagerreferentie van de vorige scène als (_currentScene) _currentScene._sceneManager = null; // stel de doelscène in als de huidige scène _currentScene = _targetScene; // zet de dummy-proof variabele uit _isInTransition = false; // en roep de methode onSceneSet () _currentScene.onSceneSet () aan;
Oke. Alles is klaar en we zijn klaar om te vertrekken. Het is tijd om een echte applicatie te maken met het framework dat we hebben gebouwd.
Open de Flash IDE en maak een nieuw Flash-document. Noem het "SceneTransitions" en maak een documentklasse met dezelfde naam. Je kunt ook een achtergrond op het podium plaatsen als je dat wilt.
Maak 4 symbolen met tekst en benoem ze naar de volgende afbeelding. In dit voorbeeld exporteert u elk symbool voor ActionScript met een klassenaam die overeenkomt met de symboolnaam.
Maak symbolen en geef ze de naam zoals in de volgende afbeelding. Maak ook hun instanties op en noem ze zoals getoond. Selecteer alle exemplaren en converteer ze als een groep naar een ander symbool met de naam 'Scene1Sprite'. Je kunt vervolgens de Scene1Sprite verwijderen uit het werkgebied (maar niet uit de bibliotheek).
Doe precies hetzelfde als de vorige stap, maar selecteer deze keer alle instanties en converteer ze naar een symbool met de naam 'Scene2Sprite'.
De documentklasse is verrassend eenvoudig. Maak gewoon een scènemanager en vertel de manager om de huidige scène in te stellen voor een intro-scène.
pakket import flash.display.Sprite; import scenes.SceneManager; public class SceneTransitions breidt uit Sprite public function SceneTransitions () var sceneManager: SceneManager = nieuwe SceneManager (); sceneManager.setScene (nieuwe IntroScene (this));
De eerste scène die we instellen voor de scènebeheerder is een introscène. Zoals de naam al doet vermoeden, is deze scène eenvoudigweg een intro voor onze hoofdscène (in plaats van het introgedeelte van het "puzzelstuk" van onze hoofdscène te zijn). De intro-opdracht (gemaakt met de methode createButroCommand overschrijven () van deze intro-scène verplaatst instanties van symbolen naar het midden van het werkgebied (door de opdracht SetProperties), voegt ze toe aan de container, tweens ze van nulschaal naar 100% schaal, en vervaagt ze tot nul alpha, de een na de ander. Dit wordt bereikt door alle afzonderlijke opdrachten te koppelen aan een enkel serieel commando (zoals u zich van Part One zou moeten herinneren).
Wanneer de intro-opdracht is voltooid, wordt de methode onSceneSet () opgeroepen en op dit moment is de eigenschap sceneManager beschikbaar en kan de methode setScene () worden gebruikt om van scène te wisselen. In de methode onSceneSet () wordt de methode setScene () van de scènebeheerder aangeroepen om over te schakelen naar Scene1 (een klasse die we in de volgende stap maken). Omdat we de createOutroCommand () niet hebben genegeerd, is de outro-opdracht van de intro-scène een dummy-commando, dat niets doet.
pakket import commands.Command; import commands.display.AddChild; import commands.display.RemoveChild; import commands.greensock.TweenMaxFrom; import commands.greensock.TweenMaxTo; import commands.scenes.SetScene; importeer commando's.SerialCommand; import commands.utils.SetProperties; import flash.display.DisplayObject; import flash.display.Sprite; import flash.filters.BlurFilter; scènes importeren. Scene; public class IntroScene breidt Scene uit // constante parameters private static const ZOOM_IN_TIME: Number = 0.2; private static const HOLD_TIME: Number = 0.3; private static const BLUR_OUT_TIME: Number = 0.2; privé static const BLUR_AMOUNT: Number = 20; private var container: Sprite; openbare functie IntroScene (container: Sprite) this.container = container; override public function createIntroCommand (): Command var blur: BlurFilter = new BlurFilter (BLUR_AMOUNT, BLUR_AMOUNT, 2); // symboolinstanties var text1: DisplayObject = new IntroText1 (); var text2: DisplayObject = new IntroText2 (); var text3: DisplayObject = new IntroText3 (); var text4: DisplayObject = new IntroText4 (); // dit is de seriële opdracht die dingen aan elkaar koppelt var-opdracht: Command = new SerialCommand (0, // "THIS" nieuwe SetProperties (text1, x: 320, y: 200), nieuwe AddChild (container, tekst1), nieuwe TweenMaxFrom (text1, ZOOM_IN_TIME, scaleX: 0, scaleY: 0), nieuwe TweenMaxTo (text1, BLUR_OUT_TIME, delay: HOLD_TIME, alpha: 0, blurFilter: blur), nieuwe RemoveChild (container, text1), // "IS" nieuwe SetProperties (text2, x: 320, y: 200), nieuwe AddChild (container, text2), nieuwe TweenMaxFrom (text2, ZOOM_IN_TIME, scaleX: 0, scaleY: 0), nieuwe TweenMaxTo (text2, BLUR_OUT_TIME, vertraging: HOLD_TIME, alpha: 0, blurFilter: blur), nieuwe RemoveChild (container, text2), // "AN" nieuwe SetProperties (text3, x: 320, y: 200), nieuwe AddChild (container , text3), nieuwe TweenMaxFrom (text3, ZOOM_IN_TIME, scaleX: 0, scaleY: 0), nieuwe TweenMaxTo (text3, BLUR_OUT_TIME, delay: HOLD_TIME, alpha: 0, blurFilter: blur), new RemoveChild (container, text3 ), // "INTRO" nieuwe SetProperties (text4, x: 320, y: 200), nieuwe AddChild (container, text4), nieuwe TweenMaxFrom (text4, ZOOM_IN_TIM E, scaleX: 0, scaleY: 0), nieuwe TweenMaxTo (text4, BLUR_OUT_TIME, delay: HOLD_TIME, alpha: 0, blurFilter: blur), new RemoveChild (container, text4),); terugkeer commando; override public function onSceneSet (): void // als de scène is ingesteld, ga direct naar scène 1 sceneManager.setScene (nieuwe Scene1 (container));
U kunt de waarde van de consts aanpassen om de tweening-effecten te wijzigen.
Laten we nu naar de Scene1-klasse kijken. De tekstvelden worden een voor een in positie geschoven; de knoppen "intro_btn" en "scene2_btn" worden geregistreerd met gebeurtenisgeluisteraars die met de muis klikken nadat ze in positie zijn getweend, bereikt door de opdrachten voor tweening samen te koppelen en luisteraars toe te voegen met een serieel commando.
Een ander ding dat de moeite van het vermelden waard is, is de opdracht AddChild die de Scene1Sprite aan de container toevoegt. Het wordt in serie aaneengeschakeld na een wachtopdracht die op één frame wacht. Omdat de klasse TweenMax alle weergaveobjecten in het volgende frame bijwerkt na de aanroep van de methode TweenMax.from (), ziet u soms een snelle "glimp" van objecten op hun definitieve plaatsen, voordat de tweening start. Het doel van de opdracht Wait hier is om TweenMax voldoende tijd te geven om objecten naar hun juiste startplaatsen te verplaatsen.
pakket 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; importeer commando's. ParallelCommand; importeer commando's.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; scènes importeren. Scene; public class Scene1 breidt Scene uit // constante parameters private static const IN_TIME: Number = 0.4; private static const OUT_TIME: Number = 0.2; private static const DELAY_TIME: Number = 0.2; privé static const BLUR_AMOUNT: Number = 20; private var container: Sprite; privé var ss: Scene1Sprite; private var blur: BlurFilter; public function Scene1 (container: Sprite) this.container = container; ss = nieuwe Scene1Sprite (); override public function 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" nieuwe TweenMaxFrom (ss.text3_mc, IN_TIME, y: 250, delay: DELAY_TIME * 2), // "1" nieuwe TweenMaxFrom (ss.text4_mc, IN_TIME, x: 400, delay: DELAY_TIME * 3), // intro button new SerialCommand (0, new TweenMaxFrom (ss.intro_btn, IN_TIME, y: 250, delay: DELAY_TIME * 4 ), nieuwe AddEventListener (ss.intro_btn, MouseEvent.CLICK, replayIntro)), // scène 2 knop nieuwe SerialCommand (0, nieuwe TweenMaxFrom (ss.scene2_btn, IN_TIME, y: 250, delay: DELAY_TIME * 5), nieuwe AddEventListener (ss.scene2_btn, MouseEvent.CLICK, gotoScene2)), // plaats de sprite van scene 1 naar het midden van de container nieuwe SetProperties (ss, x: 300, y: 200), // plaats de scène 1 sprite naar de container // wacht op één frame om dingen naar de juiste plaatsen te verplaatsen nieuwe SerialCommand (0, nieuwe wacht (1 / containe r.stage.frameRate), nieuwe AddChild (container, ss))); terugkeer commando; override public function createOutroCommand (): Command var blur: BlurFilter = new BlurFilter (BLUR_AMOUNT, BLUR_AMOUNT, 3); opdracht var: Command = new ParallelCommand (0, // display-objecten verwijderen nieuwe SerialCommand (0, // "THIS" nieuwe TweenMaxTo (ss.text1_mc, OUT_TIME, alpha: 0, blurFilter: blur), // "IS" nieuwe TweenMaxTo (ss.text2_mc, OUT_TIME, alpha: 0, blurFilter: blur), // "SCENE" nieuwe TweenMaxTo (ss.text3_mc, OUT_TIME, alpha: 0, blurFilter: blur), // "1" nieuwe TweenMaxTo (ss.text4_mc, OUT_TIME, alpha: 0, blurFilter: blur), // intro-knop nieuwe TweenMaxTo (ss.intro_btn, OUT_TIME, alpha: 0, blurFilter: blur), // scene 2 button new TweenMaxTo (ss.scene2_btn, OUT_TIME, alpha: 0, blurFilter: blur), // verwijder scène 1 sprite nieuwe RemoveChild (container, ss)), // verwijder gebeurtenislisteners nieuwe RemoveEventListener (ss.intro_btn, MouseEvent.CLICK, replayIntro), nieuwe RemoveEventListener (ss.scene2_btn, MouseEvent.CLICK, gotoScene2)); terugkeer commando; private functie replayIntro (e: Event): void sceneManager.setScene (nieuwe IntroScene (container)); private functie gotoScene2 (e: Event): void sceneManager.setScene (nieuwe Scene2 (container));
De Scene2-klasse lijkt behoorlijk op Scene1; hoewel sommige tekst is gewijzigd:
pakket 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; importeer commando's. ParallelCommand; importeer commando's.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; scènes importeren. Scene; public class Scene2 breidt Scene uit // constante parameters private static const IN_TIME: Number = 0.4; private static const OUT_TIME: Number = 0.2; private static const DELAY_TIME: Number = 0.2; privé static const BLUR_AMOUNT: Number = 20; private var container: Sprite; privé var ss: Scene2Sprite; private var blur: BlurFilter; public function Scene2 (container: Sprite) this.container = container; ss = nieuwe Scene2Sprite (); override public function createIntroCommand (): Command 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" nieuwe TweenMaxFrom (ss.text3_mc, IN_TIME, y: 250, delay: DELAY_TIME * 2), // " 2 "nieuwe TweenMaxFrom (ss.text4_mc, IN_TIME, x: 400, delay: DELAY_TIME * 3), // intro-knop new SerialCommand (0, nieuwe TweenMaxFrom (ss.intro_btn, IN_TIME, y: 250, delay: DELAY_TIME * 4), nieuwe AddEventListener (ss.intro_btn, MouseEvent.CLICK, replayIntro)), // scène 1 knop nieuw SerialCommand (0, nieuw TweenMaxFrom (ss.scene1_btn, IN_TIME, y: 250, delay: DELAY_TIME * 5 ), nieuwe AddEventListener (ss.scene1_btn, MouseEvent.CLICK, gotoScene1)), // plaats de sprite van scene 2 naar het midden van de nieuwe set Set-properties (ss, x: 300, y: 200), // voeg de scène 2 sprite naar de container // wacht op één frame om dingen naar de juiste plaatsen te verplaatsen nieuwe SerialCommand (0, nieuwe wacht (1 / container.stage.frameRate), nieuwe AddChild (container, ss))); terugkeer commando; override public function createOutroCommand (): Command var blur: BlurFilter = new BlurFilter (BLUR_AMOUNT, BLUR_AMOUNT, 3); opdracht var: Command = new ParallelCommand (0, // display-objecten verwijderen nieuwe SerialCommand (0, // "THIS" nieuwe TweenMaxTo (ss.text1_mc, OUT_TIME, alpha: 0, blurFilter: blur), // "IS" nieuwe TweenMaxTo (ss.text2_mc, OUT_TIME, alpha: 0, blurFilter: blur), // "SCENE" nieuwe TweenMaxTo (ss.text3_mc, OUT_TIME, alpha: 0, blurFilter: blur), // "2" nieuwe TweenMaxTo (ss.text4_mc, OUT_TIME, alpha: 0, blurFilter: blur), // intro-knop nieuwe TweenMaxTo (ss.intro_btn, OUT_TIME, alpha: 0, blurFilter: blur), // scene 1 button new TweenMaxTo (ss.scene1_btn, OUT_TIME, alpha: 0, blurFilter: blur), // remove scene 1 sprite new RemoveChild (container, ss)), // verwijder gebeurtenislisteners nieuwe RemoveEventListener (ss.intro_btn, MouseEvent.CLICK, replayIntro), nieuwe RemoveEventListener (ss.scene1_btn, MouseEvent.CLICK, gotoScene1)); terugkeer commando; private functie replayIntro (e: Event): void sceneManager.setScene (nieuwe IntroScene (container)); private functie gotoScene1 (e: Event): void sceneManager.setScene (nieuwe Scene1 (container));
Dat klopt, we zijn eindelijk klaar! Druk op CTRL + ENTER in Flash IDE om de film te testen en de vloeiende en naadloze overgangen tussen scènes te bekijken.
In deze zelfstudie hebben we onze eigen opdracht- en scènebeheerkaders samengesteld. We hebben heel veel code doorgenomen, maar het is absoluut de moeite waard. Nu we deze kaders bij de hand hebben, wordt scènebeheer uitgevoerd met gemakkelijk te begrijpen en te onderhouden code. Elke Flash-toepassing kan worden onderverdeeld in scènes en elke scène bestaat uit intro- en outro-opdrachten. Instructies worden ingekapseld in commando's, wat resulteert in een uniform "code uiterlijk", wat ons in staat stelt scene intro en outro op een zeer hoog niveau te beheren.
Ik hoop dat je het leuk vond, bedankt voor het lezen!
Accentsconagua