‫Ben tornato.
‫Ora in questo video parleremo di eventi di successo.
‫Vorremmo rilevare quando il proiettile colpisce qualcosa e in questo modo possiamo fare qualcosa in risposta,
‫come distruggere il proiettile.
‫E più tardi ci occuperemo di fare danni e causare esplosioni e cose del genere.
‫Quindi ora parliamo un po' degli eventi di successo.
‫Il nostro proiettile ha una componente mesh.
‫Il suo tipo è il tuo componente mesh statico e il tuo componente mesh statico è una classe in una lunga
‫gerarchia di classi e il sistema motore irreale uno dei suoi genitori è il tuo componente primitivo.
‫Ecco la pagina della documentazione per il tuo componente primitivo.
‫Dice che i componenti primitivi sono componenti visti che contengono o generano una sorta di geometria generalmente
‫da renderizzare o utilizzare come dati di collisione.
‫Quindi sono fondamentalmente componenti della scena con alcune funzionalità aggiunte.
‫E se scorri verso il basso e guardi la gerarchia, vedrai che abbiamo visto il componente e
‫derivato da quel tuo componente primitivo e puoi continuare a scorrere verso il basso e vedere tutte le altre classi
‫che derivano da te.
‫Componente primitiva.
‫Ora, il motivo per cui lo stiamo sottolineando è perché il tuo componente mesh statico eredita
‫queste funzionalità dal tuo componente primitivo e il tuo componente primitivo ha la capacità di generare eventi hit.
‫Ora, cosa intendiamo per generare eventi di successo?
‫Bene, diciamo che abbiamo una geometria nel nostro mondo rappresentata dal rettangolo a
‫destra e abbiamo un oggetto con un componente mesh statico rappresentato dal cerchio a sinistra.
‫Ora, se questo oggetto che ha un componente mesh statico si sta muovendo verso il blocco, se questo componente è
‫impostato per gestire gli eventi hit, non appena colpisce quel blocco, l'evento hit verrà generato in
‫caso di collisione.
‫Ora un evento hit genererà alcuni dati relativi a quella collisione, incluso il componente che è stato
‫colpito.
‫Quindi questo blocco qui potrebbe avere un componente mesh statico.
‫Possiamo accedere a quel componente in caso di collisione.
‫Possiamo anche accedere all'attore che è stato colpito e anche l'evento principale genera un risultato di successo EF.
‫Abbiamo imparato qualcosa sul risultato del colpo F e sappiamo che contiene molte variabili sull'evento del colpo,
‫come la posizione del colpo, che è un vettore F che rappresenta una posizione nel mondo.
‫Quindi abbiamo la nostra rete di proiettili.
‫Questa è una variabile di tipo puntatore del componente mesh statico.
‫Ora, ogni volta che questo componente mesh statico colpisce qualcosa nel mondo, vogliamo avere del codice
‫che risponda a questo.
‫Ora essendo un componente mesh statico, eredita le cose dalla tua classe componente primitiva.
‫Una delle cose che eredita è una variabile chiamata sul componente hit.
‫Ora ecco la documentazione per l'hit del componente.
‫È descritto come un evento chiamato Quando un componente colpisce o viene colpito da qualcosa di solido.
‫Ora scorrendo verso il basso, vediamo che sul colpo del componente ha la firma del colpo del componente di tipo F.
‫E se facciamo clic su questo, vediamo che la firma del colpo del componente F è una struttura.
‫Ora, tornando indietro, possiamo vedere che la documentazione dice un evento chiamato quando un componente colpisce o viene colpito
‫da qualcosa di solido.
‫Ciò potrebbe accadere a causa di cose come il movimento del personaggio utilizzando la posizione impostata con lo sweep
‫abilitato o la simulazione fisica per eventi quando gli oggetti si sovrappongono come entrare in un trigger, vedere l'evento di sovrapposizione.
‫Quindi ci sono eventi di successo e ci sono eventi di sovrapposizione.
‫Ci occupiamo di eventi di successo.
‫Quindi sappiamo che su componente hit è descritto nella documentazione come un evento hit e sappiamo che su componente
‫hit è una struct di tipo F firma hit del componente.
‫Fin qui tutto bene.
‫Ora questo evento hit sull'hit del componente è anche qualcosa che chiamiamo delegato multicast.
‫Un delegato multicast può avere più funzioni associate.
‫Possono esserci funzioni che esistono su più classi.
‫E se quelle funzioni vengono associate a questo delegato multicast, vengono aggiunte a qualcosa chiamato
‫elenco di chiamate.
‫Questo è un elenco di funzioni da chiamare quando questo evento hit indica che devono essere chiamate tutte.
‫Diciamo che questo evento di successo o un delegato multicast viene trasmesso quando succede qualcosa.
‫Quindi, nel caso in cui la nostra mesh proiettile colpisca qualcosa, il delegato trasmetterà a tutte le classi
‫che hanno una funzione associata a questo delegato.
‫Non appena la trasmissione viene inviata, tutte queste funzioni associate vengono chiamate in risposta alla
‫trasmissione.
‫Questa è una funzionalità molto potente di Unreal Engine.
‫Ci consente di avere questo qualcosa chiamato delegato, che attende un evento come una collisione.
‫Poi.
‫E il delegato verrà trasmesso, risultando in tutte le funzioni associate chiamate in risposta alla trasmissione.
‫Poiché più funzioni possono essere legate a questo delicato, lo chiamiamo multicast.
‫Sta trasmettendo a più classi che hanno le loro funzioni legate ad esso.
‫Ora, come leghiamo una funzione a questo delegato?
‫Bene, sul componente hit ha una serie di funzioni che ci consentono di farlo, una delle quali è
‫chiamata add dynamic.
‫Quindi, quando chiamiamo la funzione dinamica ADD, tutto ciò che dobbiamo fare è passare in due parametri l'oggetto utente per
‫il quale possiamo usarlo e la funzione di callback, che è l'indirizzo di alcune funzioni della nostra
‫classe.
‫Quindi, una volta che accediamo a questo sul componente, premi il delegato e chiamiamo la funzione di aggiunta dinamica, possiamo passare
‫l'oggetto utente e il callback.
‫E questo comporterà l'aggiunta di quella richiamata all'elenco di chiamate degli eventi di successo.
‫Ora sul componente hit, trasmetteremo questo delegato risultando in tutte le funzioni ad esso associate da chiamare.
‫Quindi, per associare questo delegato, dobbiamo creare una funzione di callback.
‫Quindi ecco proiettile e vorremmo una funzione di callback per l'evento hit.
‫Quindi creiamo una funzione privata qui e sarà nulla.
‫E lo chiamerò semplicemente in caso di successo.
‫Potremmo chiamarlo come vogliamo, ma sembra abbastanza descrittivo.
‫Ora questa funzione di callback deve avere la firma corretta per gli eventi hit, il che significa che il
‫suo elenco di parametri di input deve essere molto specifico.
‫Il primo parametro di input deve essere del tipo you primitive component pointer e si chiama hit comp.
‫Questo è il componente che colpisce.
‫Nel nostro caso, faremo in modo che la nostra rete di proiettili colpisca le cose.
‫Il parametro successivo è un puntatore attore chiamato Altro attore.
‫Questo sarà l'attore che è stato colpito.
‫Il prossimo parametro di input è un altro puntatore del componente primitivo chiamato other comp.
‫Questo è l'altro componente che è stato colpito.
‫Quindi, se colpiamo il componente mesh statico di qualche altro attore, allora questo sarebbe quel componente mesh statico.
‫Il prossimo è un vettore F chiamato impulso normale.
‫Se stiamo simulando la fisica, il motore fisico applicherà un impulso in risposta alla collisione.
‫E questo f vettore rappresenta la direzione e la grandezza di quell'impulso.
‫Infine, abbiamo un parametro di input di tipo const F hit result e questo è un riferimento const e si
‫chiama hit.
‫Quindi, quando l'hit viene chiamato, avremo accesso a un risultato di hit che contiene ancora più informazioni
‫sull'hit.
‫Ora, poiché lo stiamo legando a un delegato, deve essere una funzione U.
‫Quindi segneremo questo con la tua funzione.
‫Ora dovresti avere familiarità con la tua funzione.
‫È proprio come la tua proprietà solo per le funzioni anziché per le variabili.
‫Quindi molto importante.
‫La nostra richiamata deve essere una funzione u affinché funzioni.
‫Ora abbiamo dichiarato la funzione.
‫Andiamo avanti e definiamo la funzione.
‫Quindi di nuovo nei proiettili.
‫CP Appena sotto la nostra funzione tick, definiamo questa funzione.
‫Gli daremo un corpo di funzione e metteremo il nome della classe appena prima del nome della funzione, e ora abbiamo una
‫funzione di callback.
‫Quindi siamo pronti per associare questa funzione su hit al nostro delegato e dobbiamo farlo all'inizio del gioco.
‫Farlo nel costruttore è troppo presto e talvolta puoi riscontrare problemi come il tuo delegato che non
‫è vincolato.
‫Quindi lo faremo qui e inizieremo a giocare.
‫Quindi abbiamo la nostra mesh proiettile e useremo l'operatore freccia per accedere alla variabile ereditata da te.
‫Il componente primitivo chiamato su componente hit e su componente hit ha la funzione di aggiunta dinamica.
‫Ora, stranamente, il completamento automatico non funzionerà per l'aggiunta dinamica, quindi dovrai digitare l'intero
‫nome della funzione.
‫Questa è la funzione che useremo per associare la nostra callback al componente hit e aggiungere quella funzione al suo
‫elenco di chiamate.
‫Ora, per prima cosa, abbiamo bisogno dell'oggetto utente che sarà questo perché questa è la
‫classe per cui associare la funzione e quindi abbiamo bisogno dell'indirizzo della funzione che sarà l'indirizzo di on hit.
‫Quindi useremo l'indirizzo dell'operatore e la funzione un proiettile su colpo.
‫E con questo abbiamo la nostra funzione vincolata e siamo pronti a generare eventi di successo.
‫Ora possiamo testarlo con un registro UEE e possiamo utilizzare l'avviso di temperatura del registro.
‫E per il testo possiamo semplicemente dire a colpo.
‫E se lo vediamo nel registro di output, sappiamo che la nostra funzione on hit è stata chiamata,
‫compiliamola.
‫Quindi ho il registro di output aperto qui.
‫Premerò play e sparo un proiettile e c'è il mio messaggio di registro su hit è stato chiamato.
‫Quindi questo sta funzionando.
‫Ora solo una nota a margine, se entriamo nel proiettile BP e selezioniamo la mesh del proiettile nel pannello dei dettagli,
‫possiamo scorrere fino alla sezione di collisione.
‫E qui vediamo che i preset di collisione sono impostati per bloccare tutta la dinamica e che la collisione
‫abilitata è impostata su questa impostazione di query e fisica abilitate alla collisione.
‫Ciò è necessario per gli eventi di successo.
‫Dobbiamo essere in grado di eseguire query per un evento di successo.
‫E, naturalmente, la fisica consente al motore fisico di agire sulla mesh del proiettile.
‫Quindi, ora che ci siamo collegati al delegato hit del componente con la nostra funzione on hit e abbiamo inserito un
‫registro enorme per assicurarci che funzioni, vorrei che esplorassi un po' di più questa funzione in modo che possiamo
‫comprendere alcuni di questi parametri di input nella nostra funzione on hit.
‫Quindi, nella funzione al momento del colpo, aggiungi altri registri YOUI.
‫Vorrei che stampaste i nomi di alcuni di questi parametri di input usando la funzione git name.
‫Vorrei che usassi un registro YUI per stampare il nome di hit comp, altro attore e altro comp in modo da poter vedere i
‫nomi di questi oggetti che stiamo colpendo.
‫Utilizzerai il formato percentuale se, specificando nella macro di testo del registro E.
‫E proprio come promemoria, ogni volta che chiamiamo get name, dobbiamo usare l'asterisco quando passiamo quella stringa nella macro del
‫registro YUI, ad esempio, per ottenere il nome di un altro attore chiamiamo altro attore, prendiamo il nome
‫e mettiamo quell'asterisco all'inizio solo per restituire quella stringa in stile C, che è ciò che
‫si aspetta quando si formatta con una stringa.
‫Quindi metti in pausa il video e usa il login Yui nella nostra funzione di successo per stampare i nomi di hit comp, altri
‫attori e altri comp ora.
‫Bene.
‫Quindi qui in Projectile CP, userò il tuo registro qui.
‫Quindi copierò questa riga in cui sto usando Yui log e per la stringa dirò hit comp percent s
‫e subito dopo il testo chiamerò hit comp get name e ho bisogno di questo asterisco per convertire da una stringa F
‫a una stringa di stile C.
‫Ora userò questa stessa frase, solo che cambierò il testo per dire altro attore e questa volta
‫lo chiameremo nome su un altro attore.
‫E infine, stamperò altre chiamate comp, otterrò il nome su altre comp.
‫Quindi compiliamo e torniamo qui nell'editor, vado avanti e premo play e sparo un proiettile
‫e guardo questo.
‫Vediamo che hit comp è una mesh di proiettili.
‫Ricorda che abbiamo detto che questo è il componente che colpisce, che è il nostro mash
‫proiettile e vedrai che sta usando il nome che abbiamo assegnato a questo componente in crea oggetto secondario predefinito.
‫Quindi questa è una di quelle situazioni in cui viene utilizzato quel nome.
‫Ora vedrai che dice che l'altro difetto dell'attore sottolinea zero.
‫E questo perché questo attore di mesh statico che è il difetto ha il segno difetto di nome zero.
‫A volte il motore inserisce un numero alla fine del suo nome interno per attori e componenti,
‫e vedrai che succede la stessa cosa quando stampiamo altri comp.
‫L'attore della mesh statica del difetto ha un componente mesh statico e il suo nome è componente mesh statico zero.
‫Quindi questo ci fornisce un po' più di informazioni su quei parametri di input nella nostra funzione di callback su hit.
‫E questo è utile perché abbiamo accesso a quegli oggetti in C++ se vorremmo fare qualcosa in risposta
‫all'evento hit.
‫Quindi, in sintesi, abbiamo appreso degli eventi di successo e di come questi vengono implementati come delegati multicast e abbiamo
‫imparato come funzionano.
‫Abbiamo creato una funzione chiamata On Hit and Bound, quella funzione per il delegato di hit del componente che la
‫nostra mesh proiettile ha ereditato dalla tua classe di componenti primitivi.
‫Ora non abbiamo distrutto il proiettile al momento del colpo, ma ora sappiamo che possiamo farlo facilmente perché abbiamo
‫questa funzione di callback e possiamo inserire la logica in questa funzione come distruggere il proiettile.
‫Quindi ce ne occuperemo in un video futuro.
‫Per ora, datevi una pacca sulla spalla perché questa è una delle aree più complesse di Unreal Engine C++
‫che avete imparato finora.
‫Ci vediamo nel prossimo video.