‫Hallo en welkom terug.
‫Nu hebben we onze projectielklasse al gemaakt, en we zijn klaar om deze dingen in het level te
‫spawnen, zodat we ze bij de torens kunnen lanceren en ze uiteindelijk kunnen vernietigen.
‫Nu zullen spawning-acteurs de spawn-acteurfunctie betrekken.
‫Dus we gaan in deze video leren hoe dat werkt.
‫Laten we het nu hebben over het spawnen van het projectiel.
‫Dit is iets wat we graag willen doen vanuit de C++-kant van de zaak.
‫We gaan C++-functies aanroepen om dynamisch nieuwe objecten in de wereld te maken.
‫Nu spawnen we vanaf de C++-kant van de dingen, maar we willen graag een object spawnen op basis van de
‫blauwdruk van onze projectielklasse.
‫De reden is dat we een blauwdruk hebben op basis van de klasse A Projectile C++, die aanvullende
‫informatie bevat.
‫In het bijzonder heeft het die mesh-eigenschap ingesteld.
‫We kozen de mesh voor onze statische mesh-component.
‫We kunnen dus niet zomaar de C++-versie spawnen.
‫We moeten de blauwdrukversie spawnen om die mesh te krijgen.
‫Dus de vraag is hoe we een object spawnen in C++, dat is gebaseerd op een blauwdruk?
‫Welnu, we gaan leren over iets dat PT-subklasse wordt genoemd, nu is dit een sjabloon.
‫En zoals veel sjablonen, hebben de punthaken een type nodig.
‫Dus het gebruik van de PT-subklasse van vereist een typeparameter.
‫En dit stelt ons in staat om een variabele te hebben die iets opslaat dat een U-klasse wordt genoemd.
‫U-klasse vertegenwoordigt een klassetype, maar het heeft ook de mogelijkheid om te communiceren met het reflectiesysteem van de onwerkelijke
‫motor.
‫Als ik reflectie zeg, bedoel ik het uitwisselen van informatie tussen de C++ en de blauwdrukkant.
‫Met PT-subklasse van, zoals de naam al doet vermoeden, kunnen we een variabele opslaan die een klasse vertegenwoordigt op basis van het
‫type dat we doorgeven of een subklasse van dit gekozen type.
‫Dit betekent dat we een type kunnen kiezen en dat de subklasse t een u-klasse kan bevatten die dat type of een
‫daarvan afgeleid type vertegenwoordigt.
‫En dit omvat blauwdrukken op basis van het type.
‫Dus laten we eens kijken hoe deze t-subklasse van dingen werkt.
‫Oké.
‫Dus ik ben hier terug in de basis pom en de reden dat ik in de basis pod ben, is omdat we willen dat dit
‫projectiel zowel op de tank als op de torenklassen zit.
‫Beide klassen zullen projectielen voortbrengen.
‫Dus ik wil hier een t-subklasse van variabele.
‫Dus ik ga zeggen t subklasse van en tussen de punthaken moeten we een type doorgeven.
‫Nu kunnen we op deze manier zelfs tussen punthaken declareren.
‫En ik ga van het type een projectiel maken.
‫En de reden is dat we de projectielklasse hebben gemaakt en het type ervan is een projectiel.
‫Dus ik ga deze variabele maken en ik noem het projectielklasse.
‫Dit stelt ons in staat om een C++-variabele te hebben die een klassetype vertegenwoordigt, en het type kan
‫gebaseerd zijn op een projectiel, zelfs een blauwdrukklassetype dat hierop is gebaseerd.
‫Nu ga ik het een U-eigenschap geven.
‫En omdat ik dit graag zou willen kunnen bewerken, in ieder geval in de standaardblauwdruk, ga ik
‫deze bewerking als standaard instellen.
‫Pas nu kunnen we dit een categorie geven.
‫Ik plaats het in een categorie genaamd gevecht.
‫Laten we nu doorgaan en dit compileren.
‫Oké, dus ik ben terug in de editor en ik ga naar de map met blauwdrukken en van daaruit
‫naar de map Pons.
‫En ik ga gewoon BP openen -- tank en de volledige blauwdruk-editor openen.
‫Als ik nu in het detailvenster kijk, kan ik naar gevechten zoeken.
‫Hier is het.
‫En hier is de projectielklasse variabele.
‫Dit is die subklasse die we projectielklasse noemden.
‫Merk nu op dat we het hier kunnen instellen en we kunnen het instellen met behulp van een vervolgkeuzelijst.
‫En als we op de vervolgkeuzelijst klikken, hebben we drie opties.
‫We kunnen het op geen zetten, wat het standaard is ingesteld, wat in feite betekent dat het een null-aanwijzer is.
‫Of we kunnen het instellen op projectiel of BP-projectiel.
‫Dat is wat subklasse van ons in staat stelt om deze projectielklasse in te stellen op een bepaald type op basis van projectiel,
‫aangezien dat het type is dat we kozen toen we de variabele maakten.
‫Nu projectiel hier.
‫Dit is de C++-klasse die in C++ projectiel wordt genoemd.
‫Het is een projectiel, maar BP-projectiel is een blauwdruk gebaseerd op de C++-projectielklasse en we kunnen dit
‫kiezen.
‫En nu is de projectielklasse ingesteld op het BP-projectieltype.
‫Dit is geen onderdeel en het is geen BP-projectielobject.
‫Dat is niet wat het is.
‫Het slaat een type op, meer specifiek een U.
‫Klasse soort.
‫En zoals ik al zei, je klas heeft ingebouwde functionaliteit waarmee reflectie kan werken tussen C++ en
‫blauwdrukken.
‫Informatie kan tussen C++ en blauwdrukken stromen.
‫Dus nu hebben we projectielklasse, een PT-subklasse die is ingesteld op het BP-projectielblauwdruktype.
‫Dus waarom al die moeite doen om een subklasse van variabelen te creëren?
‫Welnu, we moeten bespreken hoe de spawn-acteurfunctie werkt.
‫Spawn-acteur is een functie die behoort tot de nieuwe wereldklasse.
‫Dus als we de wereld in handen krijgen, kunnen we Spawn acteur noemen.
‫En Spawn-acteur is een andere sjabloonfunctie en is ontworpen om nieuwe objecten te maken die vergelijkbaar zijn met het maken
‫van een standaardsubobject.
‫Maar create default sub-object is ontworpen voor het maken van componenten en we kunnen het alleen in de
‫constructor gebruiken voor een bepaalde klasse. spawn-acteur kan tijdens runtime worden aangeroepen terwijl het spel draait en het kan
‫actoren maken.
‫Nu is het een sjabloon, dus het vereist een type.
‫Als we een projectiel willen spawnen, dan zouden we hier een projectiel van het type C++ klasse doorgeven.
‫Dit is de C++-klasse die wordt geretourneerd door de spawn-acteurfunctie in C++.
‫Nu nemen de haakjes een aantal parameters, waaronder een U-klasse.
‫Nu zijn er meerdere overbelastingen van deze functie die verschillende invoerparameters vereisen.
‫De meest eenvoudige is misschien wel de versie die een U-klasse, een A-locatie en een rotatie nodig heeft.
‫de u.
‫Klasse is wat het type vertegenwoordigt om te spawnen.
‫Dit is het werkelijke type van het object dat wordt voortgebracht.
‫Dit kan een blauwdrukklasse zijn.
‫De locatie is een F-vector die aangeeft waar het object moet spawnen en de rotatie zal de rotatie ervan specificeren.
‫Dus een voorbeeld van de syntaxis ziet er als volgt uit.
‫We zouden spawn-acteur noemen, het klassetype specificeren en vervolgens die u-klasse-informatie doorgeven samen
‫met de locatievector en rotatierotator.
‫Dus laten we het even over je klas hebben.
‫Zoals we al zeiden, je klasse vertegenwoordigt een klassetype.
‫Wanneer we Spawn-acteur aanroepen, passeren we een U-klasse om de spawn-acteurfunctie te voorzien van informatie over
‫het te spawnen object.
‫Ja, we hebben een type tussen de punthaken doorgegeven, maar dat vertelt Spawn-acteur eenvoudig het C++-type dat moet worden
‫gemaakt.
‫Terwijl je klas meer informatie bevat.
‫Laten we zeggen dat we een blauwdruk hebben gemaakt op basis van een projectiel en dat we in de blauwdruk enkele eigenschappen hebben
‫ingesteld, zoals het kiezen van de statische mesh voor de statische mesh-component.
‫Als we nu gewoon een onbewerkte C++-klasse zouden spawnen, dan zal die statische mesh niet worden ingesteld op het
‫nieuw voortgebrachte projectielobject.
‫In wezen zouden we gewoon een onzichtbare nieuwe acteur voortbrengen.
‫Een nieuwe klassevariabele kan echter een blauwdrukklasse vertegenwoordigen.
‫Je klasse geeft ons de mogelijkheid om een variabele aan de C++-kant te hebben, die een blauwdruk,
‫klassetype en spawn vertegenwoordigt.
‫Actor kan die klasse als invoerargument nemen, zodat het een nieuw object kan voortbrengen op basis van de blauwdruk die
‫door die nieuwe klasse wordt vertegenwoordigd.
‫Dus een nieuw projectiel heeft zijn statische mesh-eigenschap ingesteld omdat we een nieuw object voortbrengen op basis
‫van de blauwdruk en niet de onbewerkte C++-klasse.
‫Dit is de reden waarom we onze subklasse van hebben gemaakt, omdat deze een nieuwe klasse kan opslaan
‫en we deze gelijk konden stellen aan BP-projectiel uit onze BP - tankblauwdruk.
‫Dus nu weet je hoe je acteurs moet spawnen.
‫Spawn-acteur behoort tot de nieuwe wereldklasse.
‫Dus als je get world aanroept en simpelweg Spawn actor aanroept, dan ken je de invoervereisten
‫voor deze functie die je doorgeeft in het C++ type tussen punthaken en je classificeert een locatie en een
‫rotatie tussen haakjes.
‫Dus voor je uitdaging ga je het projectiel spawnen, doe dit in de vuurfunctie.
‫Dus bel get world spawn actor en geef een projectiel door tussen de punthaken.
‫Dit betekent dat je het headerbestand voor projectiel moet opnemen.
‫Dus vergeet dat niet en gebruik onze nieuwe variabele projectielklasse als de invoerparameter van de U-klasse tussen
‫haakjes.
‫Nu hebben we een locatie en een rotatie nodig.
‫Je gaat het spawn-punt van het projectiel gebruiken voor zowel locatie als rotatie.
‫Van de projectiel spawn point component.
‫U kunt componentlocatie ophalen en componentrotatie ophalen om toegang te krijgen tot deze waarden.
‫Dus pauzeer de video en bel nu spawn-acteur in de vuurfunctie.
‫Oké.
‫Laten we dus naar Base Pond CP gaan waar we de vuurfunctie hebben gedefinieerd.
‫Nu hebben we hier een debug-bol tekenen.
‫Dat gaan we echt niet meer nodig hebben.
‫Dus ik ga deze functieaanroep verwijderen en in plaats daarvan ga ik Spawn-acteur hier bellen.
‫Nu hebben we al de locatie van het projectiel-spawnpunt.
‫Ik ga deze lokale variabele hernoemen naar simpelweg locatie en ik ga een nieuwe F-rotator maken.
‫Rotatie genoemd.
‫En dit krijg ik ook van het spawnpunt van het projectiel.
‫Dus het wordt een projectiel-spawn-punt om componentrotatie te krijgen.
‫Dus nu heb ik de locatie en de rotatie om het projectiel te spawnen.
‫Dus vervolgens moet ik spawn-acteur bellen, zodat ik get world kan bellen.
‫En van de wereld die ik van deze functie krijg, kan ik spawn-acteur noemen.
‫Dit heeft punthaken en haakjes, toch?
‫Dus tussen de punthaken moet ik een projectiel gebruiken.
‫En aangezien we een projectiel gebruiken, moeten we daarvoor de koptekst opnemen.
‫Dus hier ga ik debug-helpers verwijderen, tekenen en vervangen door projectiel.
‫Dus nu hebben we dat type opgenomen.
‫Nu hebben we de U-klasse nodig en op basis van H heeft projectielklasse, kunnen we die gebruiken als de U-klasse.
‫Dus we gaan slagen in de projectielklas.
‫Nu kunnen we eindelijk de locatie en rotatie doorgeven en dit zal de spawn-acteurfunctie bevredigen.
‫Dus laten we doorgaan en dit compileren en we zijn terug hier in de editor en we kunnen het spel testen.
‫Dus ik ga door en klik en controleer dat.
‫We hebben een nieuw projectiel voortgebracht.
‫We spawnen het projectiel aan het uiteinde van onze loop en ze zweven daar gewoon in de lucht, wat
‫er niet echt goed uitziet.
‫Maar dat is oke.
‫Dit is stap één.
‫We moeten eerst het projectiel spawnen, zodat het als een projectiel gaat werken als de volgende stap.
‫Dus kort samengevat, we spawnen nu projectielen.
‫Dit is een geweldige mijlpaal.
‫Het zijn echter nog niet echt projectielen.
‫Ze zweven daar gewoon en projectielen zouden door de lucht moeten vliegen.
‫Dus in de volgende video gaan we praten over hoe we onze projectielen echt door de lucht kunnen laten
‫vliegen, zodat ze zich als projectielen gedragen.
‫Ik zie je snel.