Share
Ciao amici. Il punto forte di questo tutorial è preciso colpisci il rilevamento di un laser generato. Questo tipo di intelligenza artificiale è utile per creare giochi d'azione, specialmente nel caso dell'intelligence con telecamere, pistole laser, ecc. Quindi metti il tuo razzo sulla schiena, inizia il conto alla rovescia?
Diamo un'occhiata al risultato finale su cui lavoreremo:
Apri Flash e crea un nuovo documento Flash (ActionScript 3.0).
Imposta la dimensione dello stage su qualsiasi risoluzione standard. Il mio è di 500 x 350 px.
Imposta la frequenza fotogrammi su 24 fps.
Salva il file in una cartella a tua scelta.
Creiamo ora un generatore laser.
Disegna un cerchio di raggio 20, vale a dire 40 x 40. Inoltre, riempilo con un bel colore sfumato radiale.
Ora dobbiamo convertire questo cerchio in un simbolo Flash in modo che possiamo controllarlo con ActionScript.
Seleziona il cerchio e premi F8 o vai a Modifica> Converti in simbolo. Seleziona il filmato per il tipo di simbolo. Impostare anche il punto di registrazione al centro in modo che il generatore laser ruoti dal suo centro. genere laserGenerator_MC nel campo del nome dell'istanza e infine, ma non meno importante, selezionare "Esporta per ActionScript" nel gruppo "Avanzate" in modo da poter accedere al generatore laser dalla nostra classe di documenti che incontreremo presto.
Dopo aver impostato tutte le opzioni precedenti, premere OK. Premere nuovamente OK per la finestra di dialogo che mostra l'avviso per la definizione della classe. Questo creerà una definizione di classe per il generatore laser in fase di esecuzione.
Ora non abbiamo bisogno laserGenerator_MC simbolo sullo stage poiché è disponibile nel pannello Libreria con il nome dell'identificatore laserGenerator_MC. Quindi cancella questo simbolo dallo stage. Il tuo stadio dovrebbe essere vuoto ora.
Ora aggiungiamo una bocca a questo generatore per creare la sensazione di un dispositivo. Nel pannello della libreria, fai doppio clic su laserGenerator_MC icona simbolo (lato sinistro del nome del simbolo) per entrare in modalità modifica. Aggiungi la bocca ad esso come mostrato di seguito.
Sentiti libero di aggiungere il tuo design.
Nota: Non modificare la posizione del cerchio poiché è necessario ruotarlo attorno al suo centro.
Dopo aver aggiunto una bocca al generatore, uscire dalla modalità di modifica del simbolo e tornare alla timeline principale.
Il tuo razzo ha lasciato il terreno. Il dispositivo generatore laser è pronto e in attesa di esecuzione.
Per aggiungere un dramma alla nostra scena abbiamo bisogno di ActionScript. Per agire in modo intelligente abbiamo bisogno di una classe di documenti.
In questo passaggio creeremo una struttura di base della nostra classe di documenti.
Per una spiegazione dettagliata sulla classe del documento, consulta questo suggerimento rapido.
Quindi crea un nuovo file ActionScript 3.0. Digita il seguente codice:
package public class Laser_HitDetection public function Laser_HitDetection () // codice costruttore
Salva questo documento come classe Laser_HitDetection.as nella stessa cartella in cui hai salvato il tuo FLA per questo tutorial. Bel decollo. La tua classe di documento di base è pronta.
Nel tuo file FLA accedi al pannello Proprietà per il documento e digita il nome della classe nel campo Classe documento disponibile nel gruppo "Pubblica".
Ora siamo pronti a comunicare con FLA attraverso questo Laser_HitDetection.as classe del documento.
Dovremo creare un'istanza di generatore laser dalla libreria e posizionarla al centro del palco.
Modifica il Laser_HitDetection.as classe di documento come mostrato di seguito (linee evidenziate):
pacchetto import flash.display.Sprite; public class Laser_HitDetection estende Sprite var laserGun: Sprite; // Istanza di laserGenerator_MC // Funzione pubblica del costruttore Laser_HitDetection () CreateLaserGun (); // Trova e posiziona il generatore laser dalla funzione pubblica library CreateLaserGun (): void laserGun = new laserGenerator_MC (); // Scaricalo dalla libreria addChild (laserGun); // Posiziona il generatore laser al centro del laser stage Gun.x = stage.stageWidth / 2; laserGun.y = stage.stageHeight / 2;
Se testerai il film ora, vedrai la nostra pistola laser ben posizionata al centro del palco.
Accentsconagua
CreateLaserGun () metodoNel codice sopra abbiamo usato folletto classe per creare un'istanza di oggetto Sprite che manterrà il laser. Per questo dichiariamo variabile come:
var laserGun: Sprite;
Quindi abbiamo aggiunto un nuovo metodo "CreateLaserGun ()"in cui abbiamo assegnato un'istanza di laserGenerator_MC dalla biblioteca a quanto sopra Lasergun var come:
laserGun = new laserGenerator_MC ();
Dopo averlo aggiunto al palco lo abbiamo posizionato al centro del palco come:
laserGun.x = stage.stageWidth / 2; laserGun.y = stage.stageHeight / 2;
Infine abbiamo chiamato questo metodo dal metodo costruttore della classe documento come:
// Funzione pubblica del costruttore Laser_HitDetection () CreateLaserGun ();
Il razzo sta accelerando con piena spinta. Attaccheremo molto presto questa pistola laser che proietterà il laser. Prima di ciò aggiungeremo alcuni ostacoli. Andiamo.
Per sperimentare con il rilevamento dei colpi abbiamo bisogno di alcuni ostacoli posizionati sul palco. Quindi, sul palco disegnare diverse forme che assomigliano a superfici concave-convesse, arrampicata su pendenze e bordi dritti, come mostrato di seguito:
Ora inseriremo tutte queste forme in un unico simbolo. Seleziona tutte le forme contemporaneamente e premi F8 o vai a Modifica> Converti in simbolo. Seleziona il filmato come tipo di simbolo. Nome questo simbolo obstacles_MC nel campo del testo Imposta il punto di registrazione al centro. Controlla anche "Esporta per ActionScript" in modo che possiamo accedervi dalla nostra classe di documenti.
Dopo la conversione in MovieClip abbiamo obstacles_MC nella libreria con lo stesso nome identificativo. Simlilary come laserGenerator_MC non abbiamo bisogno di questo simbolo sul palco, quindi cancellalo dal palco. Ora il tuo stadio è vuoto.
Il modo in cui abbiamo collocato il nostro laserGenerator_MC sul palcoscenico, al centro, allo stesso modo ci posizioneremo obstacles_MC simbolo sul palco. Modifica la classe del documento come mostrato di seguito:
pacchetto import flash.display.Sprite; public class Laser_HitDetection estende Sprite var laserGun: Sprite; // Istanza di laserGenerator_MC var ostacoli: Sprite; // Istanza di obstacles_MC // Funzione pubblica del costruttore Laser_HitDetection () CreateLaserGun (); CreateObstacles (); // Trova e posiziona il generatore laser dalla funzione pubblica library CreateLaserGun (): void laserGun = new laserGenerator_MC (); // Scaricalo dalla libreria addChild (laserGun); // Posiziona il generatore laser al centro del laser stage Gun.x = stage.stageWidth / 2; laserGun.y = stage.stageHeight / 2; // Trova e posiziona gli ostacoli dalla funzione pubblica della libreria CreateObstacles (): void obstacles = new obstacles_MC (); // Scaricalo dalla libreria addChild (ostacoli); // Posiziona gli ostacoli al centro del palco obstacles.x = stage.stageWidth / 2; obstacles.y = stage.stageHeight / 2;
Prova il film per vedere gli ostacoli posizionati intorno alla pistola laser.
Il tuo razzo sta raggiungendo la velocità terminale. Ora è il momento di attivare la pistola laser. Deve generare il laser da esso. Facciamolo ora.
Come imiteremo il laser? Qualche supposizione ?? Che ne dici di usare alcuni membri della classe Graphics come lineStyle (), moveTo (), lineTo (). Se conosci questi metodi, il tuo lavoro è facile. Per coloro che non conoscono questi metodi, siamo sempre con te. Vediamoli in dettaglio.
Dovremo aggiungere un nuovo metodo ProjectLaser (). Cerchiamo di modificare il nostro Laser_HitDetection classe di documento come mostrato di seguito:
// Pacchetto di costruzione import flash.display.Sprite; public class Laser_HitDetection estende Sprite var laserGun: Sprite; // Istanza di laserGenerator_MC var ostacoli: Sprite; // Istanza di ostacoli_MC var laser: Sprite; var startX: numero; // x punto iniziale del laser var startY: Number; // y punto iniziale di laser var endX: Number; // x end point of laser var endY: Number; // y end point of laser // Funzione pubblica del costruttore Laser_HitDetection () CreateLaserGun (); CreateObstacles (); ProjectLaser (); // Trova e posiziona il generatore laser dalla funzione pubblica library CreateLaserGun (): void laserGun = new laserGenerator_MC (); // Scaricalo dalla libreria addChild (laserGun); // Posiziona il generatore laser al centro del laser stage Gun.x = stage.stageWidth / 2; laserGun.y = stage.stageHeight / 2; // Trova e posiziona gli ostacoli dalla funzione pubblica della libreria CreateObstacles (): void obstacles = new obstacles_MC (); // Scaricalo dalla libreria addChild (ostacoli); // Posiziona gli ostacoli al centro del palco obstacles.x = stage.stageWidth / 2; obstacles.y = stage.stageHeight / 2; // Proietta un laser dalla funzione pubblica del dispositivo generatore laser ProjectLaser (): void laser = new Sprite (); addChild (laser); // Imposta l'origine del laser come centro della pistola laser startX = laserGun.x; startY = laserGun.y; // Imposta il punto finale del laser endX = startX + 230; endY = startY; // Disegna laser laser.graphics.lineStyle (1, 0xFF0000); laser.graphics.moveTo (startX, startY); laser.graphics.lineTo (endX, endY);
Prova il film.
Il razzo è proprio lì su nel cielo. La pistola laser ha iniziato a proiettare il laser. Come è successo? Proviamo a capire il codice sopra nel prossimo passaggio.
Nel passaggio precedente abbiamo proiettato un laser con successo. Per questo abbiamo eseguito i seguenti compiti:
Innanzitutto, abbiamo dichiarato cinque nuove variabili:
var laser: Sprite; var startX: numero; // x punto iniziale del laser var startY: Number; // y punto iniziale di laser var endX: Number; // x end point of laser var endY: Number; // y punto finale del laser
Secondo, abbiamo aggiunto un nuovo metodo ProjectLaser ():
funzione pubblica ProjectLaser (): void laser = new Sprite (); addChild (laser); // Imposta l'origine del laser come centro della pistola laser startX = laserGun.x; startY = laserGun.y; // Imposta il punto finale del laser endX = startX + 230; endY = startY; // Disegna laser laser.graphics.lineStyle (1, 0xFF0000); laser.graphics.moveTo (startX, startY); laser.graphics.lineTo (endX, endY);
ProjectLaser () MetodoNel primo metodo abbiamo creato un oggetto Sprite vuoto per contenere il laser e lo abbiamo aggiunto allo stage come mostrato di seguito:
laser = new Sprite (); addChild (laser);
Poiché volevamo che il laser iniziasse a proiettare dalla pistola laser, assegniamo il valore X della pistola laser a startx e Y valore a starty come mostrato di seguito:
startX = laserGun.x; startY = laserGun.y;
(Successivamente abbiamo fornito questi valori a moveTo (startX, startY) metodo che incontreremo presto).
Quindi abbiamo definito EndX e Endy:
endX = startX + 230; endY = startY;
I valori assegnati alle variabili precedenti sono valori temporanei. Li abbiamo usati solo per mostrare la proiezione di base di un laser. Nei prossimi passi modificheremo questi valori applicando alcuni semplici calcoli matematici. Questi valori sono fondamentali per ottenere il rilevamento perfetto del laser. Li studieremo più avanti in questa sessione.
E ora la parte importante di questo metodo. Disegnare una linea retta all'interno dell'oggetto laser sprite per imitare il laser proiettato.
Per prima cosa abbiamo gestito lo stile della linea da tracciare come mostrato di seguito:
laser.graphics.lineStyle (1, 0xFF0000);
Questo metodo lineStyle () viene utilizzato per controllare lo stile del tratto dell'oggetto di disegno come linea, rettangolo, ovale ecc. È possibile fornire un massimo di otto argomenti a questo metodo. Se non vengono specificati valori predefiniti vengono invece assegnati. Per il nostro esempio abbiamo bisogno solo di due argomenti. Il primo argomento è lo spessore della linea (vale a dire 1) e il secondo argomento è il colore della linea (es. 0xFF0000, che è rosso).
Per una spiegazione dettagliata di questo metodo, consultare il documento di aiuto di Adobe sul metodo "lineStyle (args?)".
Quindi abbiamo posizionato il punto iniziale della linea come mostrato di seguito:
laser.graphics.moveTo (startX, startY);
startx e starty assicura che il punto di partenza sia il centro della pistola laser.
Dopo di ciò abbiamo concluso la linea:
laser.graphics.lineTo (endX, endY);
Ricorda che questi endX e endY sono valori temporanei solo per mostrare la proiezione. Abbiamo bisogno che vengano regolati se qualche ostacolo si frappone al laser. Faremo questa matematica nei prossimi passi.
Quindi, abbiamo disegnato una linea da (startx, starty) a (EndX, Endy).
Il razzo sta andando e andando. Vedi quei paesaggi, paesaggi acquatici?
Ora è il momento per la vera azione. Rilevazione dei colpi con ostacoli.
Ora, siamo dotati di una pistola laser. Abbiamo anche diversi ostacoli. Siamo al livello in cui possiamo aggiungere la rilevazione del colpo che aggiungerà sicuramente il significato alla scena.
Potresti pensare che questo rilevamento estremamente preciso richieda una matematica complessa. Se è così allora ti sbagli. Utilizza semplicemente il metodo di ActionScript hitTestPoint () integrato con a per ciclo continuo. La complessa matematica dietro il perfetto rilevamento dei colpi viene gestita da questo metodo. Devi solo utilizzare questo metodo e a per loop in modo intelligente.
Stiamo per apportare alcune importanti modifiche alla nostra classe di documenti principalmente a ProjectLaser () metodo e alcuni nuovi vars, quindi osservalo e applicalo attentamente. Cerchiamo di modificarlo come mostrato:
Per prima cosa aggiungi questi nuovi vars:
var rad: Number = Math.PI / 180; // Utilizzato per calcolare l'angolo in radianti var maxDist: Number = 250; // distanza massima percorsa dal laser var adjustDist: Number; // nuova massima distanza se qualche ostacolo si presenta in un modo
Quindi modificare ProjectLaser () metodo aggiungendo per loop come mostrato di seguito (notare anche che ora EndX e Endy sono dentro per ciclo continuo):
// Proietta un laser dalla funzione pubblica del dispositivo generatore laser ProjectLaser (): void laser = new Sprite (); addChild (laser); // Imposta l'origine del laser come centro della pistola laser startX = laserGun.x; startY = laserGun.y; for (adjustedDist = 0; adjustedDist < maxDist; adjustedDist ++) //Trigonometry to aim the laser w.r.t laser gun's rotation endX = laserGun.x + Math.cos ( laserGun.rotation * rad ) * adjustedDist; endY = laserGun.y + Math.sin ( laserGun.rotation * rad ) * adjustedDist; //calculate hit test if ( obstacles.hitTestPoint ( endX, endY, true ) ) break; //Draw laser laser.graphics.lineStyle( 1, 0 x FF0000 ); laser.graphics.moveTo( startX, startY ); laser.graphics.lineTo ( endX, endY );
Prova il film.
Boom? Sono sicuro. Guardando a questo effetto sei ispirato a creare un gioco Flash con intelligenza di sicurezza. AI perfetta, per sviluppare giochi interessanti in Flash.
Prima di tutto abbiamo aggiunto nuovi vars alla nostra classe di documenti come mostrato:
Inizialmente, un angolo, in radianti
var rad: Number = Math.PI / 180; // Utilizzato per calcolare l'angolo in radianti
La precedente variante viene utilizzata in formula per calcolare un angolo in radianti.
La formula è, radianti = gradi * Math.PI / 180. Maggiori informazioni qui. Abbiamo usato questa formula nel nostro codice, in queste righe:
endX = laserGun.x + Math.cos (laserGun.rotation * rad) * adjustedDist; endY = laserGun.y + Math.sin (laserGun.rotation * rad) * adjustedDist;
Nel laserGun.rotation * rad, gradi = laserGun.rotation, e rad = Math.PI / 180.
In secondo luogo, abbiamo creato una var per la distanza massima che deve essere percorsa dal laser:
var maxDist: Number = 250; // distanza massima che deve essere percorsa dal laser
Questo var decide la distanza massima che deve essere percorsa dal laser. Poiché non è necessario disegnare il laser oltre l'area visibile, definiamo un buon punto finale. Questa var farà ciò che è necessario.
Terzo, abbiamo una var per la distanza corrente del laser al momento dell'intersezione con qualsiasi ostacolo.
var adjustedDist: Number; // nuova massima distanza se qualche ostacolo si presenta in un modo
Quando un ostacolo si avvicina al laser, il laser viene bloccato anziché viaggiare alla massima distanza.
La distanza dopo aver bloccato un laser non è altro che la distanza regolata a seconda della situazione.
Il per ciclo e hitTestPoint () ognuno gioca un ruolo importante nel calcolo di questa distanza.
In quarto luogo, abbiamo modificato ProjectLaser () metodo aggiungendo ActionScript hitTestPoint () insieme a a per ciclo continuo. Abbiamo riassegnato EndX e Endy variabili.
for (adjustedDist = 0; adjustedDist < maxDist; adjustedDist ++) //Trigonometry to aim the laser w.r.t laser gun's rotation endX = laserGun.x + Math.cos ( laserGun.rotation * rad ) * adjustedDist; endY = laserGun.y + Math.sin ( laserGun.rotation * rad ) * adjustedDist; //calculate hit test if ( obstacles.hitTestPoint ( endX, endY, true ) ) break;
Il ciclo for assicura che la distanza regolata venga aumentata fino alla massima distanza. Potresti pensare "Qual è il divertimento nel rendere la distanza regolata uguale alla distanza massima?"
In realtà, questa distanza regolata è consentita per abbinare la massima distanza naturale ma non appena colpisce qualsiasi ostacolo (che viene rilevato da hitTestPoint () metodo) questa distanza è indicata come distanza massima per quella situazione attuale. Grazie a hitTestPoint () per rendere il compito così semplice.
Abbiamo anche riassegnato EndX e Endy valori come:
endX = laserGun.x + Math.cos (laserGun.rotation * rad) * adjustedDist; endY = laserGun.y + Math.sin (laserGun.rotation * rad) * adjustedDist;
Le funzioni di trigonometria Math.cos () e Math.sin () sono utilizzati per calcolare l'angolo della rotazione della pistola laser w.r.t laser.
In forma semplice, si occupa di puntare il laser verso la pistola laser. È importante che la pistola laser e il laser siano entrambi sincronizzati. Quindi ogni volta che la pistola laser viene ruotata, il laser seguirà la rotazione.
Per ulteriori informazioni sulla trigonometria, leggi questo suggerimento rapido.
Finalmente il climax della scena:
if (obstacles.hitTestPoint (endX, endY, true)) break;
hitTestPoint () il metodo richiede tre parametri, di cui sono necessari il primo e il secondo parametro e il terzo (shapeFlag) verrà lasciato come predefinito (ad es. falso) se non specificato.
Nel nostro esempio, shapeFlag è impostato per vero dal momento che vogliamo rilevare il colpo rispetto alla forma esatta dell'oggetto target (ad es. ostacoli). Se questo valore è impostato su falso la rilevazione del colpo avviene in relazione al riquadro di delimitazione dell'oggetto e non alla forma esatta.
Il primo e il secondo parametro di hitTestPoint () definire un punto (x, y) in corrispondenza del quale verificare l'intersezione con l'oggetto di visualizzazione. Nel nostro caso ostacoli è quell'oggetto di visualizzazione, e EndX e Endy rappresenta il punto di intersezione sul palco.
Poco chiaro? Destra. Per semplificare mettiamo la logica in sequenza come segue:
per loop consente la proiezione del laser per continuare (aggiornando EndX e Endy) se entro la distanza massima.hitTestPoint () sta aspettando di rompere il per loop non appena vede l'intersezione. Una volta il per il ciclo è rotto, EndX e Endy sono congelati.EndX e Endy sono passati al Graphics.lineTo () metodo.Per aggiungere la rotazione alla pistola laser, dobbiamo apportare alcune modifiche importanti:
ProjectLaser () metodo.HitTest ().laser.graphics.clear () nel per ciclo continuo.import flash.events.Event Per prima cosa ristruttureremo il ProjectLaser () metodo spostando l'intera logica di rilevamento del colpo in un nuovo metodo HitTest ().
Quindi aggiungeremo laser.graphics.clear () dichiarazione prima laser.graphics.lineStyle (1, 0xFF0000) affermazione all'interno del per ciclo di nuovo metodo HitTest (). Questo rimuoverà la vecchia proiezione del laser dal palco quando la pistola laser inizierà a ruotare.
Vediamo come sarà dopo aver apportato tutte e quattro le principali modifiche:
funzione pubblica ProjectLaser (): void laser = new Sprite (); addChild (laser); // Imposta l'origine del laser come centro della pistola laser startX = laserGun.x; startY = laserGun.y; // Hit test public function HitTest (): void for (adjustedDist = 0; adjustedDist < maxDist; adjustedDist ++) //Trigonometry to aim the laser w.r.t laser gun's rotation endX = laserGun.x + Math.cos(laserGun.rotation * rad) * adjustedDist; endY = laserGun.y + Math.sin(laserGun.rotation * rad) * adjustedDist; //calculate hit test if (obstacles.hitTestPoint(endX,endY,true)) break; //Draw laser laser.graphics.clear(); //Removes the old laser projection laser.graphics.lineStyle( 1, 0xFF0000 ); laser.graphics.moveTo( startX, startY ); laser.graphics.lineTo ( endX, endY );
Potresti chiederti perché abbiamo fatto questi grandi cambiamenti? L'unica ragione è ENTER_FRAME evento.
Per applicare la rotazione continua, aggiungeremo un nuovo metodo, LaserGunRotation (evt: Event) che è attivato da ENTER_FRAME evento (il che significa che viene eseguito 24 volte al secondo, poiché il frame rate è 24 fps). Quando viene utilizzato questo evento, è necessario fare attenzione ad aggiungere solo tali proprietà a quelle che si desidera modificare nel periodo di tempo. Evita di inserire quei valori che rimangono costanti durante l'esecuzione.
Nel nostro caso, se osservi vecchio ProjectLaser () metodo, ha:
laser = new Sprite (); addChild (laser); // Ruota la pistola laser
Immagina di aggiungere le dichiarazioni di cui sopra in un metodo che usa ENTER_FRAME evento; quindi un nuovo oggetto Sprite laser verrebbe creato e aggiunto allo stage ripetutamente, 24 volte al secondo.
Questo è assolutamente inutile. Pertanto abbiamo ristrutturato ProjectLaser () metodo e aggiunto un nuovo metodo HitTest (). Puoi rinominare ProjectLaser () metodo a InitializeLaser () dal momento che non proietta più il laser. Ora crea solo il supporto vuoto per il laser e definisce il suo punto di partenza. La proiezione è gestita in un nuovo metodo, HitTest ().
Ora vediamo il nuovo metodo LaserGunRotation (evt: Event). Prima di ciò aggiungi la seguente dichiarazione di importazione all'inizio della classe del documento:
import flash.events.Event;
E aggiungi il seguente metodo:
// Rotate Laser Gun funzione pubblica LaserGunRotation (evt: Event): void laserGun.rotation + = 0.5; HitTest ();
Inoltre, non dimenticare di chiamare questo metodo con un ENTER_FRAME evento all'interno della funzione di costruzione come mostrato di seguito:
// Funzione pubblica del costruttore Laser_HitDetection () CreateLaserGun (); CreateObstacles (); ProjectLaser (); addEventListener (Event.ENTER_FRAME, LaserGunRotation);
Questo lo imposta per eseguire il LaserGunRotation () funzione 24 volte al secondo.
Prova il film.
Il razzo ha già penetrato le nuvole. Guarda la bellissima Terra.
In questa fase aggiungeremo un controllo per regolare la precisione della rilevazione del colpo. Questo è importante dal momento che non è necessario il rilevamento preciso del colpo ogni volta; potrebbe essere necessario un livello medio di rilevamento dei colpi. Questo aiuterà anche a ridurre il consumo della CPU al momento del rilevamento dei colpi.
Introdurremo una nuova variabile tolleranza come:
tolleranza var: Number = 1;
Quindi modificheremo il per la dichiarazione di incremento del ciclo come:
for (adjustedDist = 0; adjustedDist < maxDist; adjustedDist += tolerance)
Ora il ciclo for sarà simile a:
for (adjustedDist = 0; adjustedDist < maxDist; adjustedDist += tolerance) //Trigonometry to aim the laser w.r.t laser gun's rotation endX = laserGun.x + Math.cos(laserGun.rotation * rad) * adjustedDist; endY = laserGun.y + Math.sin(laserGun.rotation * rad) * adjustedDist; //calculate hit test if (obstacles.hitTestPoint(endX,endY,true)) break;
Ciò significa che, invece di verificare una collisione ad ogni pixel della linea laser, controlliamo solo una collisione ad ogni altro pixel, o ogni terzo pixel, ecc..
Abbassando il valore di "tolleranza" aumenterà la precisione del rilevamento di colpo ma richiederà più potenza della CPU. Prova a sperimentare valori diversi per "tolleranza".
Amici, è ora di lasciare il razzo e aprire il paracadute. Atterra tranquillamente a terra e inizia a usare la tecnica sopra nei tuoi giochi e applicazioni Flash. Godere!
In questo tutorial abbiamo visto principalmente l'utilizzo perfetto di hitTestPoint () e a per loop per creare un rilevamento preciso del colpo senza utilizzare calcoli matematici complessi.
Questo effetto può essere utilizzato in un gioco di azione di tipo di sicurezza in cui sono richieste telecamere e pistole laser.
