Thinking i Kommandoer: del 1 av 2
en
Del
Del
Del
Dette Cyber Monday Envato Tuts + kurs vil bli redusert til bare $ 3. Ikke gå glipp av.
To ganger i måneden, vi besøker noen av våre lesere favoritt innlegg fra hele historien Activetuts +. Denne opplæringen ble først publisert i mars 2010, og er første del av en serie.
Enkelt, vedlikeholde kode er vakker. Men når vi har en sekvenser av handlinger som må utløse hverandre, kan vår kode bli rotete, noe som gjør det umulig å endre senere. Kommando Pattern I denne opplæringen, vil jeg vise deg hvordan du oppretter en minimalistisk AS3 Command rammeverk, i stand til å utføre handlinger i rekkefølge, parallelt, eller med en utsette. Du vil lene hvordan du bruker dette rammeverket for å skape en kompleks effekt med enkel og ren kode. Innkapsling instruksjonene i "kommandoer" er et populært programmerings tilnærming for å forenkle ting - Command mønster er faktisk en av de mest brukte design patterns i objektorientert programmering. I utgangspunktet er kommandoen konseptet implementeres ved å opprette kommando klasser, hver klasse som representerer en type kommando. I resten av opplæringen, når jeg refererer til "en kommando", mener jeg "en kommando objekt". Du kan tenke på en kommando som en knapp på en fjernkontroll. Hver knapp gjør noe annerledes, men de er alle brukes på samme måte: du trykker på den, så den magiske skjer. Det være seg å skru på TV-en, endre kanaler, eller justere volumet, kan disse funksjonene alt gjøres ganske enkelt ved å trykke på en knapp. Bilde gjengitt av freedigitalphotos.net Konseptet med kommandoer er lik. En kommando underliggende instruksjon er akkurat som en kontrollknapp fjern funksjon. Du kan kapsle ulike instrukser til kommandoer, for eksempel sporing ut et enkelt budskap, flytte ett objekt fra ett sted til et annet, eller veksle synligheten av et visningsobjekt. Når innkapsling er gjort, kan disse utføres ganske enkelt ved å fortelle at programmet skal "trykke på knappene på fjernkontrollen", eller med andre ord, å «utføre kommandoene". Hvis du vil at programmet skal fungere annerledes kan du bare endre koden inne i Command klasse: programmet fortsatt utfører de samme kommandoene det gjorde tidligere, men den underliggende koden inne kommandoene er annerledes. Din samlet oversikt over hvilke handlinger du vil at programmet skal gjøre er atskilt fra detaljert liste med instruksjoner for hvordan hver handling som bør gjøres. " Big deal ", kan du si," jeg kunne gjøre det ved hjelp av funksjoner. Hvorfor bry å bruke kommandoer? " Ok, la oss se på to sett med kode som skaper den samme effekten, en bruker funksjoner, og den andre ved hjelp av kommandoen rammene vi skal lage i denne opplæringen. Fordelen med kommandoer vil bli klart. La oss si at vi ønsker å skape en sirkel, legge den til scenen, tween det fra usynlig til synlig over et halvt sekund, må du vente i to sekunder, tween tilbake til usynlig i løpet en annen halvt sekund, og deretter fjerne det fra scenen. Å gjøre alt dette vil vi bruke Greensock sin TweenNano klasse Hvis du bare bruker funksjoner vil koden se slik ut: Ser du hvordan vår liste over handlinger er alle viklet opp med våre instruksjoner for å utføre hver handling? For å finne ut hva som skal skje, må du følge alle de onComplete Her er den samme koden, ved hjelp av en kommando rammeverk. Her AddChild () . Resultat: ikke mer funksjon "hopper". Det er klart hva denne sekvensen kommer til å gjøre, og i hvilken rekkefølge. Det er også enkelt å endre rekkefølgen på handlingene, eller sette inn en ny handling mellom eksisterende, uten å måtte jakte rundt koden for hver handling og endre sin onComplete Kommandoer også la oss stå i kø forskjellige handlinger slik at de skjer på samme tid - men vi får til det senere En rask fungerende eksempel er verdt mer enn! tusen ord, så la oss se på de grunnleggende element i vår kommando rammeverk. Command klasse "emptiest" metoden er den utføre () metoden; Imidlertid er denne metoden den viktigste delen av kommandoen. For å skape forskjellige kommando objekter, må du utvide denne Command klasse og overstyre utføre () -metoden, fylle i instruksjonene du vil at programmet skal utføre. For å gjøre en kommando objekt arbeid, kaller du det start () metoden; det teller ned forsinkelsen ved hjelp av en Timer objekt, og kaller utføre () -metoden når timeren er ferdig med nedtellingen. En null forsinkelse betyr ganske enkelt Command objektets utføre () metoden vil bli kalt rett etter du kaller sin start () -metoden. (Merk at når kommandoen er fullført, må du ringe den komplette () metoden manuelt, til forårsaker det sende et komplett arrangement. Hensikten med denne metoden ville bli klart senere i opplæringen.) Forresten, sette opp hendelsen parameter for start () og komplett () metoder med en nullStandardVerdien er bare min personlige vane. På denne måten kan metodene kalles som du ville gjort til andre null-parameter metoder, eller kan brukes direkte som hendelsen lyttere Nå at vi har vår Command klassen, la oss begynne å spille med det med noen enkle tracing Først må vi åpne Flash IDE og opprette en ny Flash-dokument. Kall det SimpleTracing.fla Deretter oppretter et dokument klasse for Flash dokumentet. Les denne Quick Tips for en introduksjon til å dokumentere klasser Lagre den som SimpleTracing.as Opprett en nye AS-filen og kopier Command klasse (ovenfra) inn i den. Opprett en ny mappe i klassebanen heter "kommandoer" og lagre denne nye AS-fil som Command.as inni den mappen. Vi ønsker å starte ved å innkapsle et sporingsfunksjonen til kommandoer, så la oss utvide Command klasse for å lage en TraceCommand klasse for dette formålet. Denne klassen vil inneholde en melding streng å spores ut når utføre () metoden kalles, og vil kalle den komplette () -metoden etter tracing Lagre dette som TraceCommand.as, også i "kommandoer" -mappen. Se hvordan vi har overstyrt utføre () Fullfør dokumentet klasse med TraceCommand objekter. Legg lyttere for COMPLETE arrangementet av disse kommandoene Å fortelle at programmet skal kjøre kommandoene er så enkelt som å ringe Command objekter 'start () metoder. Test filmen og du vil se følgende resultat, skrives ut linje for linje med en tidsforskjell på ett sekund. Du kan også se interlacing meldinger skrives ut av kommandoene 'komplett hendelse lytteren. Samme variabel brukes til å holde referanser til ulike Command objekter, men programmet gjør det samme til variabelen. Kaller start () metode og lytt etter COMPLETE hendelse Det er tider når du ønsker å utføre flere kommandoer med komplekse timing. Her vil jeg presentere to vanlige typer kommandoer som kan utføre avanserte kommando timing: parallelle og serielle kommandoer. Begge disse er sammensatte kommandoer, noe som betyr at de inneholder flere delkommandoer. La oss sjekke dem ut én etter én En parallell kommando utfører alle kommandoene samtidig -., Eller med andre ord, i parallell. Kommandoen er fullført når alle kommandoene er fullført. Figuren nedenfor gir et visuelt konsept for en parallell kommando. De svarte pilspisser betegne "flyt" av kommandoen kjøres Nå er det på tide å lage vår klasse for parallelle kommandoer. Nedenfor er komplett kode for ParallelCommand klassen. Lagre den som ParallelCommand.as i din "kommandoer" -mappen. De kommandoene sendes til konstruktøren som ... (resten) parameter. Dette lar oss passere så mange kommandoer som vi liker å konstruktøren; de vil automatisk bli satt inn i en matrise som heter kommandoer Denne klassen overstyrer utføre () metoden; den nye utføre () -metoden kaller nå starten () metode for alle kommandoene, og lytter etter deres komplette arrangementer. Den komplette arrangement lytteren for delkommandoene teller hvor mange kommandoene har fullført; . når alle kommandoene er gjort, ParallelCommand fullstendige () metoden kalles, og sender en COMPLETE arrangementet av sitt eget La oss prøve ut ParallelCommand klassen . Opprett en ny Flash-dokument, kopiere "kommandoer" -mappen til sin klassebanen, og skrive et nytt dokument klasse som nedenfor: Fordelen med å bruke "... (resten)" parameter for konstruktøren parameter nå blir tydelig. Du kan formatere delkommandoer med riktig kode innrykk for å skrive visuelt selvforklarende koder. Test filmen og du vil se de tre meldingene spores ut på samme tid, da en endelig melding betegner ferdigstillelse av Parallelt kommando: Test filmen, og du vil se følgende tre bølger av meldinger skrives ut, med en en-gang gap mellom hver bølge: For å få et bedre inntrykk av hva som skjer, sjekk ut denne illustrasjonen: Den andre typen kompositt kommandoen er serie kommandoen. En seriell kommandoen utfører sine kommandoene etter hverandre - eller, med andre ord, i serie. For eksempel er den andre kommandoen som utføres etter fullførelsen av den første, og den tredje er utført etter fullføring av den andre. Figuren nedenfor gir et visuelt konsept for et serie kommando: Her er kildekoden for SerialCommand Class. Den overstyres utføre () -metoden kaller start () metoden i første -delkommandoen og lytter for sin komplette arrangement. Deretter starter arrangementet lytteren neste -delkommandoen og lytter for sin COMPLETE hendelse, og så videre, helt til alle kommandoene er fullført. På dette punktet, er COMPLETE begivenhet for hele SerialCommand sendes La oss bruke SerialCommand klassen å gjøre noen serie tracing. Som før, opprette en ny Flash-dokument, kopiere "kommandoer" -mappen over, og skrive et nytt dokument klasse: Test filmen og følgende meldinger spores ut én etter én, med en en-gang gap, etterfulgt av "alle kommandoer er fullført". Her er et konsept figur av dette eksempelet som hjelper deg har en bedre forståelse av hva som skjer. Så langt har vi bare utforsket den mest grunnleggende bruk 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 kommando henrettelser, og du kan kombinere flere sammensatte kommandoer for å opprette nestede kommandoer som er tilpasset dine behov. Det neste eksemplet viser hvordan du bruker ParallelCommand klasse og SerialCommand klasse for å lage slike nestede kommandoer Som før, opprette en ny Flash-dokument, kopiere " kommandoer "mappe over, og skrive et nytt dokument klasse: Test filmen og programmet vil skrive ut følgende beskjed biter én etter én, med en en-gang gap. Som i de foregående eksemplene, vil en endelig komplett melding skrives ut når alle kommandoene er fullført. Her er konseptet figur av dette eksempelet Til slutt, la oss se på en mer praktisk eksempel. Vi kommer til å bruke kommandoen rammene vi har bygget for å skape en lys krets demo, med avansert timing. Før vi begynner, (du gjettet det) oppretter en ny Flash-dokument, kopiere "kommandoer" -mappen over, og opprette et nytt dokument klasse Lag et filmklipp symbol, med en tidslinje animasjon hvor en sirkel skifter farge fra grå til gul. I tidslinjen i siste keyframe, legg til følgende kode. Dette fører til at filmklipp å stoppe animere og sende en COMPLETE hendelse: Hvis du ønsker å unngå koding på tidslinjen, kan du opprette en klasse for lys MovieClip, med en funksjon: ... og deretter i konstruktøren for den klassen, skriver følgende: Ordne lette forekomster på scenen og navngi dem som figuren nedenfor viser: Dra en knapp komponent fra Components Panel på scenen og gi den navnet "start_btn". Vi ønsker å utføre våre kommandoer når denne knappen trykkes Lag et tekstfelt på scenen og skriv inn din ferdigmelding. Neste, konvertere den til et filmklipp symbol, og navnet på forekomsten "completeMessage_mc" Nå er det på tide å redigere dokumentet klassen. Erklære en privat variabel "circuitCommand", som vil bli brukt til å holde en referanse til en Command objekt: I begynnelsen av programmet, skal alle lysene slås av, dvs stoppet på det første bildet, og ferdigstillelse meldingen bør være skjult. Så vi kaller reset () i konstruktøren Deretter oppretter våre nestede kommandoer som spiller lyset filmklipp 'animasjoner, belysning dem opp med riktig timing. Vi bruker en PlayCommand klasse her, som bare kaller et filmklipp glød () -metoden. Vi skal skrive klassen senere. Deretter lytte etter COMPLETE ved kommandoen og CLICK tilfelle på startknappen: Tilbake kretsen og starte kommandoen når startknappen klikkes. Den siste delen for dokumentet klassen er reset () -metoden. Ingenting å gjøre med kommandoer her Den siste delen av dette eksemplet er PlayCommand klasse. Som nevnt før, hva det gjør er så enkelt som å kalle et filmklipp glød () -metoden. Så snart stykket () metoden kalles i kommandoens styres utføre () -metoden, den komplette () metoden kalles også Lagre dette som PlayCommand.as i din "kommandoer" -mappen Greit, vi er ferdig! Nå teste filmen, og du vil se at lysene blir tent opp fra venstre mot høyre etter starten klikkes. Fullført-meldingen vises når alle lysene er tent opp Her er den visuelle representasjon av hva som skjer i dette. Eksempel: Sammenlign det til selve koden, og se hvor enkelt det er å forstå: Igjen, med riktig kode hakk, et kompleks nestet kommando kan uttrykkes som enkelt og ren kode. I denne opplæringen du har lært begrepet kommandoer. Instruksjoner kan bli innkapslet i kommandoer som har identiske grensesnitt, akkurat som hver knapp på en fjernkontroll har en annen handling, men metoden for å påberope hver handling er det samme:. Trykk på knappen Også denne opplæringen introdusert deg til to typer kompositt kommandoer: parallell og serie. Disse kan brukes til å lage nestede kommandoer som åpner for avansert kommandoen kjøres timing samtidig kode rent. Konseptet med kommandoer er veldig praktisk og kraftig. Kode innkapsling er den viktigste metode for å forenkle ting ut under programmeringen, og en av de mest brukte metoder er bruk av kommandoobjekter. Jeg håper denne opplæringen hjelper deg å forstå bedre hvordan å bruke kommandoer i praktisk bruk. I neste del av denne opplæringen, vil jeg vise deg hvordan du kan integrere TweenLite med kommandoen rammene vi har skapt i denne opplæringen, deretter håndtere sceneoverganger med enkel og ren kode. Tusen takk for at du leser.
holder ting rent.
Command Innkapsling
Hvorfor bry seg med kommandoer?
Var sirkel. Circle = new Circle (); addChild (sirkel); TweenNano.from (sirkel, 0,5, {alfa: 0, onComplete: func1}); funksjon func1 (): void {TweenNano.to (sirkel, 0,5, {forsinkelse: 2, alpha: 0, onComplete: func2}); } funksjon func2 (): void {removeChild (sirkel);}
s og se hvor de fører
Var sirkel: Circle = ny sirkel (); Var kommando: Command = new SerialCommand (0, ny AddChild (dette, sirkel), ny TweenNanoFrom (sirkel, 0,5, {alpha: 0}), ny TweenNanoTo (sirkel, 0,5, {forsinkelse: 2 , alfa: 0}), ny removeChild (dette, sirkel)); command.start ();
, TweenNanoFrom
, TweenNanoTo
, og removeChild
er alle Command klasser som vi definerer andre steder i koden, og SerialCommand
er en annen Command klassen vi kan bruke til å lage sekvenser av kommandoer på sparket
eiendom.
Kommando Class
pakke kommandoer {import flash.events.Event; import flash.events.EventDispatcher; import flash.events.TimerEvent; import flash.utils.Timer; public class Command strekker EventDispatcher {private Var _timer: Timer; offentlig funksjon Command (forsinkelse: Number = 0) {_timer = new Timer (int (1000 * forsinkelse), 1); _timer.addEventListener (TimerEvent.TIMER_COMPLETE, onTimerComplete); } Private funksjon onTimerComplete (e: Timerevent): void {utføre (); } /** * Starter kommandoen. * Waits for timeren til å fullføre og kaller utføre () -metoden. * Denne metoden kan bli brukt direkte som en hendelse lytteren. * /Public endelige funksjon start (e: Hendelses = null): void {_timer.start (); } /** * Den abstrakte metoden for deg å overstyre å lage din egen kommando. * /Funksjon som er beskyttet utføre (): void {} /** * Full kommandoen. * Dispatches en komplett arrangement. * Denne metoden kan bli brukt direkte som en hendelse lytteren. * /Beskyttet endelige funksjon komplett (e: Hendelses = null): void {dispatchEvent (ny hendelse (Event.COMPLETE)); }}}
Eksempel:. Simple Tracing
Trinn 1:. Lag en Flash dokument
Trinn 2:. Opprett dokument Class
pakke {import flash.display.Sprite.; public class SimpleTracing strekker Sprite {offentlig funksjon SimpleTracing () {}}}
Trinn 3:. Opprett Base Command Class
< hr>
Trinn 4: The Trace Command
pakken kommandoer {public class TraceCommand strekker Command {private Var _message. String; offentlig funksjon TraceCommand (forsinkelse: Antall, message: String) {super (forsinkelse); _message = melding; } Ride beskyttet funksjon utføre (): void {trace (_message); fullstendig(); }}}
fungere for å gjøre denne kommandoen faktisk gjør noe
Trinn 5: Trace
pakke {import commands.Command.; import commands.TraceCommand; import flash.display.Sprite; import flash.events.Event; public class SimpleTracing strekker Sprite {offentlig funksjon SimpleTracing () {var kommandoen: Command; command = ny TraceCommand (0, "første kommandoen"); command.addEventListener (Event.COMPLETE, onCommandComplete); command.start (); command = new TraceCommand (1, "nestkommanderende"); command.addEventListener (Event.COMPLETE, onCommandComplete); command.start (); command = ny TraceCommand (2, "tredje kommando"); command.addEventListener (Event.COMPLETE, onCommandComplete); command.start (); } Private funksjon onCommandComplete (e: Hendelses): void {trace ("en kommando er fullført"); }}}
Composite Kommandoer
Parallel Command
Den ParallelCommand Class
. Vi får se skjønnheten i denne spesielle typen parameter svært kort tid
pakke kommandoer {import flash.events.Event.; public class ParallelCommand strekker Command {private Var _commands: Array; offentlig funksjon ParallelCommand (forsinkelse: Antall, ... kommandoer) {//...commands er "... (resten)" parameter super (forsinkelse); _commands = kommandoer; } Private Var _completeCommandCount: int; styre endelige beskyttet funksjon utføre (): void {//satt fullstendig kommandoen teller null _completeCommandCount = 0; for hver (var kommando: Command i _commands) {//lytte for hele arrangementet av en delkommando ... command.addEventListener (Event.COMPLETE, onSubcommandComplete); //...and starte -delkommandoen command.start (); }} Privat funksjon onSubcommandComplete (e: Hendelses): void {//slutte å lytte til hele hendelsen Command (e.target) .removeEventListener (Event.COMPLETE, onSubcommandComplete); //øke hele kommandoen count _completeCommandCount ++; //hvis alle kommandoene er komplett ... if (_completeCommandCount == _commands.length) {//...then dette parallelt kommandoen er fullført komplett (); }}}}
Eksempel: Parallel Tracing
pakke {import commands.Command; import commands.ParallelCommand; import commands.TraceCommand; import flash.display.Sprite; import flash.events.Event; public class ParallelTracing strekker Sprite {offentlig funksjon ParallelTracing () {var parallelCommand: Command = new ParallelCommand (0, ny TraceCommand (0, "første av tre"), ny TraceCommand (0, "andre av tre"), ny TraceCommand (0 "3. 3")); parallelCommand.addEventListener (Event.COMPLETE, onCommandComplete); parallelCommand.start (); } Private funksjon onCommandComplete (e: Hendelses): void {trace ("alle kommandoer er fullført"); }}}
første av tre
andre av tre
tredje av tre
alle kommandoer er komplett
< p> Hva med å sette opp forsinkelser innenfor en parallell kommando? Enkel. Endre dokumentet klassens konstruktør funksjon slik:
offentlig funksjon ParallelTracing () {var parallelCommand: Command = new ParallelCommand (0, ny TraceCommand (0, "første bølgen, første av to"), ny TraceCommand (0, "først bølge, andre 2 "), new TraceCommand (1," andre bølge, 1. 3 "), new TraceCommand (1," andre bølge, andre av tre "), new TraceCommand (1," andre bølge, tredje av tre "), ny TraceCommand (2," bølge siste, første av to "), ny TraceCommand (2," bølge siste, andre av to ")); parallelCommand.addEventListener (Event.COMPLETE, onCommandComplete); parallelCommand.start ();}
første bølgen, første av to
første bølgen, andre av to
andre bølge, første av tre
andre bølgen , andre av tre
andre bølgen, tredje av tre
bølge siste, første av to
siste bølge, andre av to
Serie Command
Den SerialCommand Class
pakke kommandoer {import flash.events.Event.; public class SerialCommand strekker Command {private Var _commands: Array; offentlig funksjon SerialCommand (forsinkelse: Antall, ... kommandoer) {super (forsinkelse); _commands = kommandoer; } Private Var _completeCommandCount: int; styre endelige beskyttet funksjon utføre (): void {//satt fullstendig kommandoen teller null _completeCommandCount = 0; //lytte for hele arrangementet av den første -delkommandoen ... _commands [0] .addEventListener (Event.COMPLETE, onSubcommandComplete); //...and starte delkommandoen _commands [0] .start (); } Private funksjon onSubcommandComplete (e: Hendelses): void {//slutte å lytte til hele hendelsen Command (e.target) .removeEventListener (Event.COMPLETE, onSubcommandComplete); //øke hele kommandoen count _completeCommandCount ++; //hvis alle kommandoene er komplett ... if (_completeCommandCount == _commands.length) {//...then dette serie kommandoen er fullført komplett (); } Else {//...otherwise lytte for hele arrangementet av neste -delkommandoen ... _commands [_completeCommandCount] .addEventListener (Event.COMPLETE, onSubcommandComplete); //...and starte delkommandoen _commands [_completeCommandCount] .start (); }}}}
Eksempel: Serie Tracing
pakke {import commands.Command; import commands.SerialCommand; import commands.TraceCommand; import flash.display.Sprite; import flash.events.Event; public class SerialTracing strekker Sprite {offentlig funksjon SerialTracing () {var serialCommand: Command = new SerialCommand (0, ny TraceCommand (0, "første kommandoen"), ny TraceCommand (1, "nestkommanderende"), ny TraceCommand (1, " tredje kommandoen ")); serialCommand.addEventListener (Event.COMPLETE, onCommandComplete); serialCommand.start (); } Private funksjon onCommandComplete (e: Hendelses): void {trace ("alle kommandoer er fullført"); }}}
nestkommanderende
tredje kommando
Nøstet Composite Kommandoer
Eksempel:. Nestede Kommandoer
pakke {import commands.Command; import commands.ParallelCommand; import commands.SerialCommand; import commands.TraceCommand; import flash.display.Sprite; import flash.events.Event; public class NestedCommands strekker Sprite {offentlig funksjon NestedCommands () {var nestedCommands: Command = new SerialCommand (0, nye ParallelCommand (0, ny TraceCommand (0, "parallell kommando # 1, del 1 av 2"), ny TraceCommand (0, "parallell kommando # 1, del 2 av 2"), ny TraceCommand (0, "------------------------------- - ")), ny ParallelCommand (1, ny TraceCommand (0," parallell kommandoen # 2, del 1 av 3 "), ny TraceCommand (0," parallell kommandoen # 2, del 2 av 3 "), ny TraceCommand (0 "parallell kommandoen # 2, del 3 av 3"), ny TraceCommand (0, "------------------------------ - ")), ny ParallelCommand (1, ny TraceCommand (0," siste kommando "), ny TraceCommand (0," ---------------------- ---------- "))); nestedCommands.addEventListener (Event.COMPLETE, onCommandComplete); nestedCommands.start (); } Private funksjon onCommandComplete (e: Hendelses): void {trace ("alle kommandoer er fullført"); }}}
parallelt kommando # 1, del 2 av 2
--------------------------------
parallelt kommandoen # 2, del 1 av 3
parallelt kommandoen # 2, del 2 av 3
parallelt kommandoen # 2, del 3 av 3
--------------------------------
siste kommando
------------------------------- -
. Eksempel: Lys Circuit
Trinn 1:. The Light Symbol
stop (); dispatchEvent (ny hendelse (Event.COMPLETE));
offentlig funksjon reachedEndOfAnimation (): void {stop (); dispatchEvent (ny hendelse (Event.COMPLETE));}
addFrameScript (4, reachedEndOfAnimation) //der 4 er én mindre enn antall rammer
Trinn 2: The Circuit
Trinn 3: Interaksjon
Trinn 4:. Ferdigstillelse Indicator
Trinn 5:. Dokument Class
private Var circuitCommand: Command;
reset ();.
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 (0.5, ny PlayCommand (0, light_4_1), ny PlayCommand (0, light_4_2)), ny PlayCommand (0,5, light_5));
circuitCommand.addEventListener (Event.COMPLETE, onCommandComplete); start_btn.addEventListener (MouseEvent.CLICK, startCircuit);
Trinn 6: Legg tilstelninger Handlers
< p> Vis den ferdigmelding når kommandoen er fullført:
privat funksjon onCommandComplete (e: Hendelses): void {completeMessage_mc.visible = true;}
privat funksjon startCircuit (e: MouseEvent): void {reset (); circuitCommand.start ();}
Trinn 7: Reset Method
privat reset funksjon (). 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
pakke kommandoer {import flash.display.MovieClip.; import flash.events.Event; public class PlayCommand strekker Command {private Var _movieClip: MovieClip; offentlig funksjon PlayCommand (forsinkelse: Antall, MovieClip: MovieClip) {super (forsinkelse); _movieClip = MovieClip; } Ride beskyttet funksjon utføre (): void {_movieClip.addEventListener (Event.COMPLETE, komplett); _movieClip.play (); }}}
Trinn 9:. Test Movie
ny 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 (0,5, ny PlayCommand (0, light_4_1), new PlayCommand (0, light_4_2)), new PlayCommand (0,5, light_5));
Sammendrag
Konklusjon