Tenk i kommandoer Del 1 av 2

To ganger i måneden besøker vi noen av våre leseres favorittinnlegg fra hele historien til Activetuts +. Denne opplæringen ble først publisert i mars 2010, og er den første delen av en serie.

Enkel, vedlikeholdbar kode er vakker. Men når vi har en sekvens av handlinger som trenger å utløse hverandre, kan vår kode bli rotete, noe som gjør det umulig å endre senere. De Kommando Mønster holder ting rent.

I denne veiledningen vil jeg vise deg hvordan du lager et minimalistisk AS3-kommandoramme, som kan utføre handlinger i rekkefølge, parallelt eller med forsinkelse. Du vil lene deg hvordan du bruker dette rammeverket for å lage en komplisert effekt med enkel og ren kode.


Kommando Encapsulation

Encapsulating instruksjoner i "kommandoer" er en populær programmeringsmetode for å forenkle ting - kommandoprønnet er faktisk et av de mest brukte designmønstrene i objektorientert programmering. I utgangspunktet implementeres kommandokonseptet ved å opprette kommandoklasser, hver klasse representerer en type kommando. I resten av opplæringen, når jeg refererer til "en kommando", mener jeg "et kommandobjekt".

Du kan tenke på en kommando som en knapp på fjernkontrollen. Hver knapp gjør noe annerledes, men de er alle brukt på samme måte: du trykker på den, så skjer magien. Hvis du slår på TVen, endrer kanalene eller justerer volumet, kan disse funksjonene gjøres ved å trykke på en knapp.

Bildetilfredshet med freedigitalphotos.net

Begrepet kommandoer er det samme. En kommandos underliggende instruksjon er akkurat som en fjernkontrollknapps funksjon. Du kan inkapslere forskjellige instruksjoner i kommandoer, for eksempel å spore ut en enkel melding, flytte ett objekt fra ett sted til et annet, eller bytte synlighet til et displayobjekt. Når innkapslingen er ferdig, kan disse utføres ved å fortelle programmet å "trykke på fjernkontrollknappene", eller med andre ord å "utføre kommandoene".

Hvis du vil at programmet skal fungere annerledes, kan du bare endre koden inne i kommandoklassen: programmet utfører fortsatt de samme kommandoene det gjorde tidligere, men den underliggende koden inne i kommandoene er annerledes. Din overordnede liste over handlingene du vil at programmet skal gjøre er atskilt fra den detaljerte listen over instruksjoner for hvordan hver handling skal utføres.


Hvorfor bry deg med kommandoer?

"Big deal," kan du si, "Jeg kunne gjøre det ved å bruke funksjoner. Hvorfor bry deg med kommandoer?" Ok, la oss se på to sett med kode som skaper den samme effekten, en som bruker funksjoner, og den andre bruker kommandobanen vi lager i denne opplæringen. Fordelen med kommandoer blir tydelig.

La oss si at vi vil lage en sirkel, legge den til scenen, mellom den fra usynlig til synlig over et halvt sekund, vent i to sekunder, mellom tilbake til usynlig over et halvt sekund, og fjern det fra scenen. For å gjøre alt dette bruker vi Greensocks TweenNano-klasse.

Hvis du bare bruker funksjoner, ser koden ut slik:

 var sirkel: sirkel = ny sirkel (); addChild (sirkel); TweenNano.from (sirkel, 0,5, ala: 0, onComplete: func1); funksjon func1 (): void TweenNano.to (sirkel, 0,5, forsinkelse: 2, alfa: 0, onComplete: func2);  funksjon func2 (): void removeChild (sirkel); 

Ser du hvordan vår liste over handlinger er alt sammen opptatt med våre instruksjoner for å utføre hver handling? For å finne ut hva som skal skje, må du følge alle onCompletes og se hvor de leder.

Her er den samme koden, ved hjelp av et kommandoramme:

 var sirkel: sirkel = ny sirkel (); var-kommandoen: Kommando = ny SerialCommand (0, ny AddChild (denne sirkelen), ny TweenNanoFrom (sirkel, 0,5, ala: 0), ny TweenNanoTo (sirkel, 0,5, forsinkelse: 2, alfa: 0) nytt RemoveChild (dette, sirkel)); command.start ();

Her, AddChild (), TweenNanoFrom, TweenNanoTo, og removeChild er alle kommandoklasser som vi definerer andre steder i koden, og SerialCommand er en annen kommandoklass vi kan bruke til å lage sekvenser av kommandoer på fluen.

Resultat: ingen funksjon "hopp". Det er klart hva denne sekvensen skal gjøre, og i hvilken rekkefølge. Det er også enkelt å endre rekkefølgen av handlingene, eller sett inn en ny handling mellom eksisterende, uten å måtte jakte på koden for hver handling og endre dens onComplete eiendom.

Kommandoer lar oss også kjøre opp forskjellige handlinger slik at de skjer samtidig - men vi kommer til det senere!


Kommandoklassen

Et raskt fungerende eksempel er verdt mer enn tusen ord, så la oss se på det essensielle elementet i vårt kommandoramme: kommandoklassen.

 pakke kommandoer import flash.events.Event; importer flash.events.EventDispatcher; importer flash.events.TimerEvent; importere flash.utils.Timer; Kommunal klasse Kommandoen utvider EventDispatcher private var _timer: Timer; offentlig funksjon Kommando (forsinkelse: Nummer = 0) _timer = ny Timer (int (1000 * forsinkelse), 1); _timer.addEventListener (TimerEvent.TIMER_COMPLETE, onTimerComplete);  privat funksjon onTimerComplete (e: TimerEvent): void execute ();  / ** * Starter kommandoen. * Venter på at timeren skal fullføres og kaller metoden execute (). * Denne metoden kan brukes direkte som en hendelselytter. * / Offentlig sluttfunksjonstart (e: Event = null): void _timer.start ();  / ** * Den abstrakte metoden for å overstyre for å lage din egen kommando. * / beskyttet funksjon utføre (): void  / ** * Fullfører kommandoen. * Sender en komplett hendelse. * Denne metoden kan brukes direkte som en hendelselytter. * / beskyttet sluttfunksjon fullført (e: Event = null): void dispatchEvent (ny hendelse (Event.COMPLETE)); 

Den "emptiest" metoden er execute () metoden; Denne metoden er imidlertid den viktigste delen av kommandoen. For å kunne opprette forskjellige kommandobjekter må du utvide denne kommandoklassen og overstyre metoden execute (), fylle ut instruksjonene du vil at programmet skal utføre.

For å gjøre et kommandobjekt arbeider, ringer du sin start () metode; det teller ned forsinkelsestiden ved hjelp av et Timer-objekt, og kaller modusen execute () når timeren fullfører nedtellingen. En nullforsinkelsestid betyr ganske enkelt at kommandobjektets execute () -metode vil bli kalt rett etter at du ringer til start-metoden.

(Merk at når kommandoen er fullført, må du kalle hele () -metoden manuelt, slik at den sender en COMPLETE-hendelse. Formålet med denne metoden blir senere senere i opplæringen.)

For øvrig er det bare min personlige vane å sette inn hendelsesparameteren for start () og fullfør () metoder med null nullverdi. På denne måten kan metodene kalles som du ville gjøre med andre nullparametermetoder, eller kan brukes direkte som hendelselyttere.


Eksempel: Enkel sporing

Nå som vi har vår kommandoklasse, la oss begynne å spille med det med enkel oppsporing.


Trinn 1: Lag et Flash-dokument

Først må vi åpne Flash IDE og opprette et nytt Flash-dokument. Kaller det SimpleTracing.fla.


Trinn 2: Opprett dokumentklassen

Deretter oppretter du en dokumentklasse for dette Flash-dokumentet. Les denne Quick Tip for en introduksjon til dokumentklasser.

 pakke import flash.display.Sprite; offentlig klasse SimpleTracing utvider Sprite offentlig funksjon SimpleTracing () 

Lagre det som SimpleTracing.as.


Trinn 3: Opprett basekommandoklassen

Opprett en ny AS-fil og kopier kommandoklassen (fra over) til den.

Opprett en ny mappe i klassestien din, kalt "kommandoer" og lagre denne nye AS-filen som Command.as i den mappen.


Trinn 4: Trace Command

Vi ønsker å begynne med å inkapsle en sporing-funksjon i kommandoer, så la oss forlenge kommandoklassen for å opprette en TraceCommand-klasse for dette formålet. Denne klassen vil inneholde en meldingsstreng som skal spores når metoden execute () kalles, og vil kalle hele () -metoden etter sporing.

 pakke kommandoer offentlig klasse TraceCommand utvider kommando private var _message: String; offentlig funksjon TraceCommand (forsinkelse: Nummer, melding: String) super (forsinkelse); _message = message;  overstyr beskyttet funksjon utfør (): void trace (_message); fullstendig(); 

Lagre dette som TraceCommand.as, også i "kommandoer" -mappen. Se hvordan vi har overstyrt henrette() funksjon for å gjøre denne kommandoen faktisk gjøre noe?


Trinn 5: Spor

Fullfør dokumentklassen med TraceCommand-objekter. Legg til lyttere for COMPLETE-hendelsen for disse kommandoene.

 pakke import kommandoer.kommando; importere kommandoer.TraceCommand; importer flash.display.Sprite; importere flash.events.Event; offentlig klasse SimpleTracing utvider Sprite offentlig funksjon SimpleTracing () var command: Command; command = new TraceCommand (0, "first command"); command.addEventListener (Event.COMPLETE, onCommandComplete); command.start (); command = new TraceCommand (1, "second command"); command.addEventListener (Event.COMPLETE, onCommandComplete); command.start (); command = new TraceCommand (2, "tredje kommando"); command.addEventListener (Event.COMPLETE, onCommandComplete); command.start ();  privat funksjon onCommandComplete (e: Event): void trace ("en kommando er fullført"); 

Å telle programmet for å utføre kommandoene er like enkelt som å kalle kommandobjektens start () -metoder. Test filmen, og du får se følgende utskrift, skrevet ut linje for linje med et tidsrom på ett sekund. Du kan også se de interlacing-meldingene som skrives ut av kommandoerens komplette hendelseslytter. Den samme variabelen brukes til å holde referanser til forskjellige kommandoobjekter, men programmet gjør det samme med variabelen: ring startmetoden () og lytt etter en komplett hendelse.


Komposittkommandoer

Det er tider når du vil utføre flere kommandoer med komplisert timing. Her presenterer jeg to vanlige kommandoer som kan utføre avansert kommandotiming: parallelle og serielle kommandoer. Begge disse er sammensatte kommandoer, noe som betyr at de inneholder flere underkommandoer. La oss sjekke dem ut en etter en.


Parallell kommando

En parallellkommando utfører alle sine underkommandoer samtidig - eller med andre ord parallelt. Kommandoen er fullført bare når alle delkommandoene er ferdige. Følgende figur gir et visuelt konsept av en parallell kommando. De svarte pilehoder angir "flyt" av kommandoen


Parallelkommandoklassen

Nå er det på tide å lage vår klasse for parallelle kommandoer.

Nedenfor er den komplette koden for ParallelCommand-klassen. Lagre det som ParallelCommand.as i mappen "kommandoer".

Underkommandoene sendes til konstruktøren som? (resten) parameter. Dette lar oss passere så mange kommandoer som vi liker til konstruktøren; de blir automatisk satt inn i en gruppe som heter kommandoer. Vi vil se skjønnheten i denne spesielle typen parameter veldig kort tid.

 pakke kommandoer import flash.events.Event; offentlig klasse ParallelCommand utvider kommando private var _commands: Array; offentlig funksjon ParallelCommand (forsinkelse: Nummer, kommandoer) //? kommandoer er parameteren "? (resten)" super (forsinkelse); _commands = kommandoer;  privat var _completeCommandCount: int; overstyre den endelige beskyttede funksjonen utfør (): void // angi hele kommandotellingen til null _completeCommandCount = 0; for hver (var-kommandoen: Kommandoen i _kommandoer) // lytt etter den komplette hendelsen til en underkommando? command.addEventListener (Event.COMPLETE, onSubcommandComplete); //? og start underkommandoen command.start ();  privat funksjon onSubcommandComplete (e: Event): void // slutte å lytte til den komplette hendelsen Command (e.target) .removeEventListener (Event.COMPLETE, onSubcommandComplete); // øke hele kommandotellingen _completeCommandCount ++; // hvis alle kommandoene er ferdige? hvis (_completeCommandCount == _commands.length) //? da er denne parallelle kommandoen fullført fullstendig (); 

Denne klassen tilsidesetter fremgangsmåten execute (); Metoden new execute () kaller nå startmetoden til alle underkommandoer, og lytter etter sine COMPLETE-hendelser. Den komplette hendelseslytteren for underkommandoene teller hvor mange delkommandoer som er fullført. Når alle delkommandoene er ferdige, blir ParallelCommandens komplette () -metode kalt, og sender en komplett event av seg selv.


Eksempel: Parallell sporing

La oss prøve ut ParallelCommand-klassen. Opprett et nytt Flash-dokument, kopier "kommandoer" -mappen til klassestien, og skriv en ny dokumentklasse som nedenfor:

 pakke import kommandoer.kommando; importere kommandoer.ParallelCommand; importere kommandoer.TraceCommand; importer flash.display.Sprite; importere flash.events.Event; offentlig klasse ParallelTracing utvider Sprite offentlig funksjon ParallelTracing () var parallelCommand: Command = ny ParallelCommand (0, ny TraceCommand (0, "1st of 3"), ny TraceCommand (0, "2nd of 3"), ny TraceCommand , "3 av 3"),); parallelCommand.addEventListener (Event.COMPLETE, onCommandComplete); parallelCommand.start ();  privat funksjon onCommandComplete (e: Event): void trace ("alle kommandoer er ferdige"); 

Fordelen med å bruke parameteren "? (Resten)" for konstruktørparameteren blir nå tydelig. Du kan formatere underkommandoene med riktig kodeinntrykk for å skrive visuelt selvforklarende koder.

Test filmen, og du vil se de tre meldingene som spores ut samtidig, og en endelig melding som angir fullføringen av parallellkommandoen:

  • 1 av 3
  • 2 av 3
  • 3. av 3
  • alle kommandoene er ferdige

Hva med å sette opp forsinkelser i en parallellkommando? Enkel. Endre dokumentklassens konstruktørfunksjon slik:

 offentlig funksjon ParallelTracing () var parallelCommand: Command = ny ParallelCommand (0, ny TraceCommand (0, "first wave, 1st of 2"), nye TraceCommand (0, "first wave, 2nd of 2"), nye TraceCommand , den andre bølgen, den første av 3), den nye TraceCommand (1, "Second Wave, 2nd of 3"), den nye TraceCommand (1, "Second Wave, 3rd of 3"), 1, 2 "), ny TraceCommand (2," siste bølge, 2: a av 2 ")); parallelCommand.addEventListener (Event.COMPLETE, onCommandComplete); parallelCommand.start (); 

Test filmen, og du får se de følgende tre bølgene av meldinger skrevet ut, med et sekunders mellomrom mellom hver bølge:

  • Første bølge, 1. av 2
  • Første bølge, 2. av 2


  • andre bølge, 1 av 3
  • andre bølge, 2 av 3
  • andre bølge, 3. av 3


  • siste bølge, 1 av 2
  • siste bølge, 2 av 2

For å få en bedre ide om hva som skjer, sjekk ut denne illustrasjonen:


Seriell kommando

Den andre typen komposittkommando er seriekommandoen. En seriell kommando utfører sine underkommandoer etter hverandre - eller med andre ord i serie. For eksempel blir den andre kommandoen utført etter ferdigstillelsen av den første og den tredje blir utført etter ferdigstillelse av den andre. Følgende figur gir et visuelt konsept av en seriell kommando:


SerialCommand Class

Her er kildekoden for SerialCommand Class. Metoden overstyrt execute () kaller start () -metoden til den første underkommandoen og lytter etter sin COMPLETE-hendelse. Deretter starter hendelseslytteren neste underkommando og lytter etter sin KOMPLETE-hendelse, og så videre, til alle underkommandoer er fullført. På dette tidspunktet sendes COMPLETE-hendelsen for hele SerialCommand.

 pakke kommandoer import flash.events.Event; offentlig klasse SerialCommand utvider kommando private var _commands: Array; offentlig funksjon SerialCommand (forsinkelse: Nummer, kommandoer) super (forsinkelse); _commands = kommandoer;  privat var _completeCommandCount: int; overstyre den endelige beskyttede funksjonen utfør (): void // angi hele kommandotellingen til null _completeCommandCount = 0; // hør etter den komplette hendelsen til den første underkommandoen? _commands [0] .addEventListener (Event.COMPLETE, onSubcommandComplete); //? og start underkommandoen _commands [0] .start ();  privat funksjon onSubcommandComplete (e: Event): void // slutte å lytte til den komplette hendelsen Command (e.target) .removeEventListener (Event.COMPLETE, onSubcommandComplete); // øke hele kommandotellingen _completeCommandCount ++; // hvis alle kommandoene er ferdige? hvis (_completeCommandCount == _commands.length) //? da er denne seriekommandoen fullført fullstendig ();  ellers //? ellers lytt etter den komplette hendelsen til neste underkommando? _commands [_completeCommandCount] .addEventListener (Event.COMPLETE, onSubcommandComplete); //? og start underkommandoen _commands [_completeCommandCount] .start (); 

Eksempel: Seriell sporing

La oss bruke SerialCommand-klassen til å gjøre noen seriell sporing. Som før, opprett et nytt Flash-dokument, kopier mappen "kommandoer" og skriv en ny dokumentklasse:

 pakke import kommandoer.kommando; importere kommandoer.SerialCommand; importere kommandoer.TraceCommand; importer flash.display.Sprite; importere flash.events.Event; offentlig serie SerialTracing utvider Sprite offentlig funksjon SerialTracing () var seriellCommand: Command = new SerialCommand (0, ny TraceCommand (0, "first command"), nye TraceCommand (1, "second command"), nye TraceCommand tredje kommando ")); serialCommand.addEventListener (Event.COMPLETE, onCommandComplete); serialCommand.start ();  privat funksjon onCommandComplete (e: Event): void trace ("alle kommandoer er ferdige"); 

Test filmen, og følgende meldinger blir sporet ut en for en, med et sekunders mellomrom, etterfulgt av "alle kommandoer er fullført".

  • første kommando


  • andre kommando


  • tredje kommando

Her er et konseptbilde av dette eksemplet som hjelper deg med å få en bedre forståelse av hva som skjer.


Nestede komposittkommandoer

Så langt har vi bare utforsket den mest grunnleggende bruken av parallelle og serielle kommandoer, og det ser ikke ut til å være noe poeng å bruke dem i stedet for separate kommandoer. Men det er tider når du trenger mye mer komplekse kommandoen henrettelser, og du kan kombinere flere sammensatte kommandoer for å lage nestede kommandoer som passer dine behov. Det neste eksemplet viser hvordan du bruker ParallelCommand-klassen og SerialCommand-klassen til å lage slike nestede kommandoer.


Eksempel: Nestede kommandoer

Som før, opprett et nytt Flash-dokument, kopier mappen "kommandoer" og skriv en ny dokumentklasse:

 pakke import kommandoer.kommando; importere kommandoer.ParallelCommand; importere kommandoer.SerialCommand; importere kommandoer.TraceCommand; importer flash.display.Sprite; importere flash.events.Event; offentlig klasse NestedCommands utvider Sprite public function NestedCommands () var nestedCommands: Command = new SerialCommand (0, ny ParallelCommand (0, ny TraceCommand (0, "parallell kommando # 1, del 1 av 2"), nye TraceCommand (0, "parallell kommando # 1, del 2 av 2"), ny TraceCommand (0, "------------------------------- - ")), ny ParallelCommand (1, ny TraceCommand (0," parallell kommando # 2, del 1 av 3 "), ny TraceCommand (0," parallell kommando # 2, del 2 av 3 "), ny TraceCommand , "parallell kommando # 2, del 3 av 3"), ny TraceCommand (0, "------------------------------ - ")), ny ParallelCommand (1, ny TraceCommand (0," Last Command "), ny TraceCommand (0," ---------------------- ---------- "))); nestedCommands.addEventListener (Event.COMPLETE, onCommandComplete); nestedCommands.start ();  privat funksjon onCommandComplete (e: Event): void trace ("alle kommandoer er ferdige"); 

Test filmen, og programmet vil skrive ut følgende melding biter en-for-en, med et sekunders mellomrom. Som i de foregående eksemplene vil en endelig fullstendig melding bli skrevet ut når alle underkommandoene er fullført.

  • parallell kommando # 1, del 1 av 2
  • parallell kommando # 1, del 2 av 2
  • --------------------------------


  • parallell kommando # 2, del 1 av 3
  • parallell kommando # 2, del 2 av 3
  • parallell kommando # 2, del 3 av 3
  • --------------------------------


  • siste kommando
  • --------------------------------

Her er konseptfiguren i dette eksemplet.


Eksempel: Lyskrets

Til slutt, la oss se på et mer praktisk eksempel. Vi skal bruke kommandorammen vi har bygget for å lage en lyskrets demo, med avansert timing. Før vi begynner, (du gjettet det), opprett et nytt Flash-dokument, kopier "kommandoer" -mappen over, og opprett en ny dokumentklasse.


Trinn 1: Lys Symbolet

Opprett et filmklippsymbol med en tidslinjeanimasjon hvor en sirkel endrer fargen fra grått til gult.

I tidslinjen, ved siste keyframe, legger du til følgende kode. Dette fører til at filmklippet slutter å animere og sende en COMPLETE-hendelse:

 Stoppe(); dispatchEvent (nytt arrangement (Event.COMPLETE));

Hvis du vil unngå koding på tidslinjen, kan du opprette en klasse for din lyse filmklipp, med en funksjon:

 offentlig funksjon reachedEndOfAnimation (): void stop (); dispatchEvent (nytt arrangement (Event.COMPLETE)); 

? og deretter i konstruktøren for den klassen skriver du følgende:

 addFrameScript (4, reachedEndOfAnimation) // hvor 4 er en mindre enn antall rammer

Trinn 2: Kredsløpet

Ordne lys forekomster på scenen og navn dem som følgende figur viser:


Trinn 3: Interaksjon

Dra en knappkomponent fra komponentpanelet til scenen og navnet "start_btn". Vi vil utføre kommandoene våre når denne knappen trykkes.


Trinn 4: Komplettindikator

Opprett et tekstfelt på scenen og skriv inn ferdigstillingsmeldingen. Deretter konverterer du det til et filmklippssymbol, og navnet på forekomsten "completeMessage_mc".


Trinn 5: Dokumentklassen

Nå er det på tide å redigere dokumentklassen. Erklære en privat variabel "circuitCommand", som vil bli brukt til å holde en referanse til et kommandobjekt:

 privat var circuitCommand: Command;

Ved begynnelsen av programmet skal alle lysene slås av, dvs. stoppet ved første ramme, og ferdigstillingsmeldingen skal være skjult. Så vi kaller reset () -metoden i konstruktøren.

 tilbakestille();

Deretter lager du våre nestede kommandoer som spiller filmklippene i lyset, belyser dem med riktig timing. Vi bruker en PlayCommand-klasse her, som bare kaller en filmklipps spill () -metode. Vi skal skrive klassen senere.

 circuitCommand = new SerialCommand (0.5, ny PlayCommand (0, light_1), ny ParallelCommand (0,5, ny PlayCommand (0, light_2_1), ny PlayCommand (0, light_2_2)), ny PlayCommand (0.5, light_3), ny ParallelCommand ny PlayCommand (0, light_4_1), ny PlayCommand (0, light_4_2)), ny PlayCommand (0.5, light_5));

Deretter lytter du etter COMPLETE-hendelsen til kommandoen og CLICK-hendelsen på startknappen:

 circuitCommand.addEventListener (Event.COMPLETE, onCommandComplete); start_btn.addEventListener (MouseEvent.CLICK, startCircuit);

Trinn 6: Legg til hendelseshåndterere

Vis fullførelsesmeldingen når kommandoen er fullført:

 privat funksjon onCommandComplete (e: Event): void completeMessage_mc.visible = true; 

Tilbakestill kretsen og start kommandoen når startknappen klikkes.

 Private funksjon startCircuit (e: MouseEvent): void reset (); circuitCommand.start (); 

Trinn 7: Tilbakestillingsmetoden

Den siste delen av dokumentklassen er reset () -metoden. Ingenting å gjøre med kommandoer her.

 privat funksjon tilbakestilling (): void completeMessage_mc.visible = false; light_1.gotoAndStop (1); light_2_1.gotoAndStop (1); light_2_2.gotoAndStop (1); light_3.gotoAndStop (1); light_4_1.gotoAndStop (1); light_4_2.gotoAndStop (1); light_5.gotoAndStop (1); 

Trinn 8: PlayCommand Class

Den siste delen av dette eksemplet er klassen PlayCommand. Som nevnt før, er det så enkelt som å kalle en filmklipps spill () -metode. Så snart spillet () -metoden kalles i kommandoen er overstyrt execute () -metoden, kalles hele () -metoden også.

 pakke kommandoer import flash.display.MovieClip; importere flash.events.Event; offentlig klasse PlayCommand utvider kommando private var _movieClip: MovieClip; offentlig funksjon PlayCommand (delay: Number, movieClip: MovieClip) super (forsinkelse); _movieClip = movieClip;  tilsidesatte beskyttet funksjon utfør (): void _movieClip.addEventListener (Event.COMPLETE, komplett); _movieClip.play (); 

Lagre dette som PlayCommand.as i mappen "kommandoer".


Trinn 9: Test filmen

Ok, vi er ferdige! Test nå filmen, og du får se lysene lyser opp fra venstre til høyre etter at startknappen er klikket. Fullførelsesmeldingen vises når alle lysene lyser.

Her er den visuelle representasjonen av hva som foregår i dette eksempelet:

Sammenlign det med den faktiske koden, og se hvor lett det er å forstå:

 Ny PlayCommand (0, light_2_2)), ny PlayCommand (0.5, light_3), ny ParallelCommand (0,5, ny PlayCommand (0,5, ny PlayCommand (0, light_1) (0, light_4_1), ny PlayCommand (0, light_4_2)), ny PlayCommand (0.5, light_5));

Igjen, med riktig kodeindrykning, kan en kompleks innestilt kommando uttrykkes som enkel og ren kode.


Sammendrag

I denne opplæringen har du lært begrepet kommandoer. Instruksjoner kan innkapsles i kommandoer som har like grensesnitt, akkurat som hver knapp på fjernkontrollen har en annen handling, men metoden for å påkalle hver handling er det samme: trykk på knappen.

Også denne opplæringen introduserte deg til to typer sammensatte kommandoer: parallell og seriell. Disse kan brukes til å lage nestede kommandoer som tillater forhåndsvisning av kommandoen, samtidig som koden er ren.


Konklusjon

Begrepet kommandoer er veldig praktisk og kraftig. Kodeinnkludering er den viktigste tilnærmingen til å forenkle ting under programmering, og en av de mest brukte metodene er bruk av kommandobjekter. Jeg håper denne opplæringen hjelper deg med å forstå bedre hvordan du bruker kommandoer i praktiske applikasjoner.

I neste del av denne opplæringen vil jeg vise deg hvordan du integrerer TweenLite med kommandorammen vi opprettet i denne opplæringen, og håndter deretter sceneoverganger med enkel og ren kode. Tusen takk for lesing.