‫Hoi.
‫Welkom terug.
‫Nu hebben we een callback-functie ingesteld die is gebonden aan de gemachtigde bij het nemen van eventuele schade.
‫En de laatste stap is om die schadegebeurtenis daadwerkelijk te genereren.
‫En we willen dit doen als ons projectiel iets raakt.
‫Zodra we uitzenden voor deze afgevaardigde, kunnen we schade toebrengen aan het ding dat we raken.
‫En we gaan dit evenement uitzenden met toegepaste schade, die tot de gameplay-statica-klasse
‫behoort.
‫Laten we dus eens kijken naar de toegepaste schadefunctie.
‫Hier is de documentatie voor toegepaste schade die de gespecificeerde actor pijn doet met generieke schade.
‫Dit is dus een generieke functie voor het aanbrengen van schade.
‫En wat we doen naar aanleiding van uitzendingen voor deze afgevaardigde is aan ons.
‫Nu zien we dat we gameplay-statistieken moeten opnemen en in de syntaxis zien we verschillende invoerparameters.
‫Nu krijgen we eigenlijk een beschrijving van de parameters.
‫Als we naar beneden blijven scrollen, zien we dat de beschadigde acteur goed is, de acteur die de
‫basisschade zal oplopen, is de basisschade om hier echt beschrijvende documentatie toe te passen.
‫Bedankt.
‫Epic event aanstichter is de controller die verantwoordelijk was voor het veroorzaken van deze schade.
‫En er staat bijvoorbeeld de speler die het wapen heeft geschoten.
‫Als er speler staat, verwijst het naar die controller.
‫Dan hebben we de schadeveroorzaker, de actor die de schade daadwerkelijk heeft veroorzaakt.
‫Er staat de granaat die ontplofte.
‫In ons geval is het het projectiel dat explodeerde.
‫En tot slot hebben we de schadetypeklasse, een klasse die de schade beschrijft die is aangericht.
‫Nu een back-up in de syntaxissectie, we kunnen de typen van deze invoer zien en we zien dat
‫schadetypeklasse een subklasse is van en we hebben eerder gezien dat TW-subklasse van zal voldoen aan een invoerparameter
‫van type U-klasse.
‫Welnu, als we schade toepassen noemen, kunnen we een U-klasse doorgeven die het type schade vertegenwoordigt dat we willen
‫gebruiken.
‫Dus we zullen het hebben over hoe we zo meteen aan deze invoerparameter gaan voldoen.
‫Dus de statische functie van het spel van de tint, toegepaste schade zal een paar invoerparameters vergen.
‫Dus laten we een strategie bedenken hoe we de juiste waarden gaan doorgeven wanneer we deze functie aanroepen, we
‫zagen dat we eerst de beschadigde actor nodig hebben.
‫Laten we teruggaan naar projectiel CP waar we schade aanbrengen zouden willen noemen.
‫We willen het graag hier doen en we hebben deze logs niet meer nodig.
‫Dus ik ga ze gewoon verwijderen en merk op dat onze callback bij een hit een aantal inputs krijgt doorgegeven zodra
‫deze wordt aangeroepen.
‫Wanneer de afgevaardigde van de hit op component wordt uitgezonden, zullen we zien dat we een andere acteur hebben.
‫Dus we hebben toegang tot de acteur die geraakt is door het projectiel en dit is de acteur die we
‫willen beschadigen.
‫Dus dat zorgt voor de eerste invoerparameter.
‫Het wordt die andere acteur.
‫Vervolgens hebben we het schadebedrag nodig, wat betekent dat ons projectiel een schadevariabele moet hebben, zodat we
‫weten hoeveel schade we moeten aanbrengen.
‫Dus waarom gaan we niet in op projectiel FX en voegen een schadevariabele toe en dit kan een float zijn.
‫Dus we kunnen deze schade gewoon noemen en we kunnen het initialiseren naar een waarde, laten we zeggen zoiets als 50
‫F en aangezien dit iets is waar we waarschijnlijk mee willen experimenteren, kunnen we dit een U-eigenschap geven om het
‫bloot te leggen en het te laten bewerken overal.
‫Dus nu hebben we een schadebedrag om door te geven als we schade opnemen.
‫Nu is de volgende parameter de aanstichter en we zagen dat dit van type A controller is.
‫Dus hoe gaan we de controller krijgen?
‫Welnu, we hebben gezien dat we de eigenaar van een bepaald onderdeel kunnen krijgen met de functie eigenaar ophalen.
‫En dit geeft de acteur terug die eigenaar is van een bepaald onderdeel, deze projectielen worden dynamisch voortgebracht.
‫Dus we moeten ervoor zorgen dat als we get owner gaan bellen dat de owner is ingesteld, we deze
‫nu uit de basispion spawnen.
‫Dus als we naar de basispion gaan.
‫CP Hier is de regel waar we de acteur voortbrengen, maar Spawn Actor geeft ook een verwijzing naar de acteur die werd
‫voortgebracht, zodat we deze in een lokale variabele kunnen opslaan.
‫We kunnen bijvoorbeeld auto-projectiel zeggen en de waarde toewijzen die wordt geretourneerd door spawn-acteur.
‫Als u nu niet bekend bent met auto, kan de compiler het type achterhalen dat aan deze nieuwe variabele moet
‫worden toegewezen.
‫Als je eroverheen beweegt, zul je zien dat het de projectielaanwijzer van het type A heeft, want
‫dat is wat we ondertekenen vanuit de spawn-acteurfunctie.
‫Dus dit is hetzelfde alsof we hier een projectielwijzer hadden geplaatst en nu hebben we toegang tot dat
‫nieuw voortgebrachte projectiel.
‫En de reden dat we dat willen doen, is dat we de eigenaar willen instellen.
‫We willen er zeker van zijn dat de eigenaar is ingesteld op de pion die hem heeft voortgebracht.
‫We kunnen dus projectiel zeggen.
‫En er is een functie voor deze set-eigenaar genaamd.
‫De eigenaar van de set neemt een acteur en we gaan hierin door, zodat wanneer een van onze pionnen een
‫projectiel spawnt, het die projectieleneigenaar zal instellen.
‫Op die manier krijgen we de instantie van de klasse die eigenaar is van dat projectiel, als we
‫ooit de eigenaar van het projectiel noemen.
‫Dus hier in projectiel-DHCP hebben we onze get owner-functieaanroep en we kunnen dit opslaan in een lokale
‫variabele.
‫Ik ga door en gebruik auto opnieuw en noem dit mijn eigenaar en stel het in op het resultaat dat wordt geretourneerd
‫door eigenaar ophalen.
‫Dus nu hebben we een lokale actor-aanwijzer die de waarde van de eigenaar opslaat.
‫Nu hebben we toegang tot de aanstichter-controller van deze acteur.
‫Voordat we dit doen, is het een goed idee om te controleren of mijn eigenaar niet nul is.
‫Dus ik ga zeggen dat als mijn eigenaar null is gelijk aan nul pointer, dan ga ik gewoon terug.
‫Als je lichaam een enkele verklaring als deze heeft, kun je deze op dezelfde regel plaatsen zonder de accolades
‫voor het geval je het niet wist.
‫En null-pointer is een sleutelwoord in C++ waarmee je kunt controleren of een pointer een null-pointer is.
‫Dus als mijn eigenaar nul is, zullen we eerder uit de functie terugkeren en niets anders doen.
‫Nu, zoals ik al zei, we kunnen de aanstichter-controller van mijn eigenaar krijgen en dat
‫is wat het gebruik van de functie genaamd get instigator-controller heet.
‫En als we hier met de muis over gaan, zullen we zien dat het een A-controller-aanwijzer retourneert.
‫Ik ga gewoon auto gebruiken en dit opslaan in een lokale variabele die ik mijn eigenaar-aanstichter zal noemen.
‫Dus nu weten we wat we moeten doorgeven als aanstichter.
‫De volgende invoer is de schadeveroorzaker en dit is de acteur die de schade voor het projectiel aanricht.
‫Dit wordt gewoon dit.
‫En dat laat de laatste invoerparameter over, die een schadetype is.
‫En we zagen dat het een subklasse is waarvan we de juiste gebruiksklasse nodig hebben om te slagen.
‫N Nu is hier de onwerkelijke motordocumentatie voor uw type schade.
‫Er staat dat een type schade bedoeld is om een bepaalde vorm van schade te definiëren en te beschrijven en om
‫een manier te bieden om reacties op schade uit verschillende bronnen aan te passen.
‫Nu gaan we onze schade niet aanpassen.
‫We hoeven alleen maar te voldoen aan de invoerparameter, wat betekent dat we een U-klasse-waarde nodig hebben die
‫dit type schadeklasse vertegenwoordigt.
‫Als we nu in C ++ de YOU-klasse van een bepaalde klasse willen krijgen, zoals je type schade, kunnen we een
‫functie aanroepen met de naam statische klasse.
‫Dit wordt geërfd van de klasse you object.
‫Nu gebruiken we natuurlijk je schadetype hier, dus we hebben die header nodig.
‫Dus uit de documentatie zal ik de include-regel kopiëren en deze hier bovenaan projectiel CP
‫plakken. En nu zul je zien dat deze statische klassefunctie een U-klasse-aanwijzer retourneert en dat nieuwe klasse het
‫nieuwe schadetype zal vertegenwoordigen C++ klasse.
‫Omdat we geen blauwdruk maken op basis van je type schade en wat extra gegevens instellen, hebben we
‫niet echt een subklasse van variabelen nodig.
‫Dus in dit geval kunnen we statische klasse gebruiken en dit zal een U-klasse retourneren die dit type vertegenwoordigt.
‫En we kunnen dit opslaan in een variabele als we willen, en ik noem dit type schadeklasse.
‫En dit is wat we kunnen doorgeven als de laatste parameter om schade toe te passen.
‫Dus we hebben nu alle informatie die we nodig hebben om door te geven aan de functie schade toepassen.
‫Maar voordat we dit doen, wil ik een paar controles plaatsen om er zeker van te zijn dat het gepast is dat we
‫deze functie aanroepen.
‫Dus ik zal hier een if-statement maken.
‫Ten eerste wil ik ervoor zorgen dat de andere acteur niet nul is.
‫Dus ik ga hier een andere acteur plaatsen.
‫Ik ga een en hier plaatsen zodat ik kan controleren of een andere acteur niet gelijk is aan deze acteur.
‫We willen onszelf geen schade berokkenen als we het projectiel zijn nu ga ik een ander uiteinde plaatsen
‫en ervoor zorgen dat andere acteur niet gelijk is aan mijn eigenaar.
‫Het zou niet goed zijn als het projectiel de eigenaar schade toebrengt.
‫En als we nu in deze if-verklaring komen, dan weten we dat het gepast is om schade toe te passen, zodat
‫we dit kunnen doen.
‫En dat wordt jouw uitdaging.
‫Dus in onze nieuwe if-instructie in de on hit-functie roept u de game-play-statistieken op om de schade-functie toe te passen.
‫Dit betekent dat je de juiste header voor gameplay-statistieken moet opnemen en dat je weet welke invoerparameters
‫je moet doorgeven.
‫Dus pauzeer de video en voeg de functieaanroep toe om nu schade toe te passen in de on hit-functie.
‫Oké.
‫Dus ik ben hier in projectiel CP en ik ga het headerbestand voor gameplay-statistieken opnemen en we kunnen
‫op de pagina Applied Damage Documentation zien dat de include kismet slash gameplay-statistieken is.
‫Dus ik ga dat erin plakken en nu ben ik klaar om schade aan te brengen.
‫Dus ik noem je gameplay-statistieken die schade toebrengen.
‫Zodra ik die openingshaakjes typ, krijg ik de pop-up die me herinnert aan de invoerparameters die ik nodig
‫heb.
‫En de eerste is de beschadigde acteur en dat wordt een andere acteur.
‫Dus we gaan hierna een andere acteur typen.
‫We hebben het schadebedrag nodig en we hebben deze schadevlotter toegevoegd in projectiel FX, die we hebben ingesteld op 50.
‫Dus ik ga hierna langs de schade.
‫We hebben de aanstichter nodig en we hebben de aanstichter van mijn baas.
‫Dus ik ga mijn baasje aanstichter doorgeven.
‫De volgende is de schadeveroorzaker.
‫En natuurlijk is het projectiel zelf de schadeveroorzaker.
‫Hier gaan we dus aan voorbij.
‫En tot slot hebben we de subklasse van voor jou schadetype nodig waarvan we weten dat een U-klasse-aanwijzer daaraan zal
‫voldoen en daarom hebben we onze schadetypeklasse.
‫Dus laten we doorgaan in de klasse van het type schade.
‫En daarmee roepen we nu schade toe.
‫Dus als we dit noemen, zullen we de schadegebeurtenis genereren en de eventuele schadeafgevaardigde zal als
‫reactie hierop uitzenden, wat betekent dat in onze gezondheidscomponent schade zal worden genoemd.
‫Dus we moeten hier gewoon iets doen om de schade op te lopen.
‫Het zou logisch zijn om deze schade te nemen en dat bedrag af te trekken van de gezondheid.
‫Maar voordat we dat doen, wil ik er zeker van zijn dat de schade niet kleiner is dan of gelijk is aan nul.
‫F Het is zinvol om deze controles uit te voeren voordat schade wordt gedocumenteerd, om er zeker van te zijn dat we geen
‫waarde toepassen die nergens op slaat, zoals nul of een negatieve waarde.
‫Dus als dat het geval is, gaan we gewoon terug.
‫En natuurlijk, als je gelikt wilt zijn en doen wat ik deed in projectiel bij CP, kunnen we de retour
‫daar plaatsen.
‫Als we nu voorbij deze lijn komen, is schade een positieve waarde, dus we kunnen gezondheid nemen en minus gebruiken
‫is gelijk aan schade.
‫En om er zeker van te zijn dat dit werkt, waarom plaatsen we hier geen euy-log?
‫Dus Yui log log, tijdelijke waarschuwingstekst en we kunnen gewoon de waarde van gezondheid afdrukken met procent F en gezondheid en
‫daarmee kunnen we compileren.
‫Nu met een succesvolle compilatie, gaan we terug naar de editor en met ons uitvoerlogboek open, laten we op
‫play drukken.
‫Laten we nu kijken of we geraakt kunnen worden door een projectiel.
‫En daar gaan we.
‫Onze gezondheid is nu gedaald tot 50 en als we opnieuw worden geraakt, hebben we nogal wat treffers gehad
‫omdat we heel snel heel vaak tegen het projectiel aanliepen.
‫Maar we zien dat onze gezondheid goed documenteert.
‫We moeten er dus voor zorgen dat we het juiste gedrag toepassen bij overlijden wanneer de gezondheid nul bereikt.
‫Maar we moeten er ook voor zorgen dat we deze hit niet meerdere keren spammen.
‫Nu weten we dat het projectiel vernietigd moet worden wanneer het iets raakt, dus de beste manier om spamming van het
‫getroffen evenement te voorkomen, is door het projectiel te vernietigen.
‫Dus dat is het laatste wat we in deze video doen.
‫Dus terug in het projectiel net na aangebrachte schade, wat we kunnen doen is het projectiel zichzelf laten vernietigen en
‫dat kan niet eenvoudiger.
‫We noemen gewoon de vernietigingsfunctie.
‫Dus met nog een compilatie hier in de editor, kunnen we doorgaan en geraakt worden door een projectiel en daar naar
‫kijken.
‫Het projectiel is weg.
‫Dus het doet zijn schade en dan verdwijnt het.
‫En natuurlijk kunnen we testen hoe we de torens raken door ze met projectielen te beschieten en ervoor te
‫zorgen dat die treffers worden geactiveerd.
‫En zoals je kunt zien, kan ik dit spammen met een hele hoop projectielen en we
‫zullen zien dat de gezondheidswaarde van deze arme toren hier heel, heel negatief wordt.
‫Dus kort samengevat hebben we de functie schade toepassen genoemd en dit resulteerde in een uitzending voor de vertegenwoordiger
‫van eventuele schade.
‫We hebben de gezondheid gedocumenteerd in de gezondheidscomponent en we hebben het projectiel vernietigd.
‫Dus schade hebben we nu opgevangen.
‫We hebben nog niet voor de dood gezorgd.
‫Dus dat zal een van de volgende dingen zijn die we in een toekomstige video zullen behandelen.
‫Ik zie je snel.