‫Hallo en welkom.
‫In deze lezing gaan we toegang krijgen tot de overlappende acteurs in iets dat een array
‫wordt genoemd, zodat we de acteurs die we in dit volume zien volledig vanuit C++ kunnen afdrukken.
‫Laten we erin duiken en kijken hoe het gedaan is.
‫Laten we ons, net als in eerdere analogieën, voorstellen dat een type of een variabele een vak is waarin we een waarde plaatsen.
‫Wat gebeurt er als we niet weten hoeveel waarden we willen opslaan?
‫We kunnen veel variabelen maken.
‫Als we wisten dat we er vijf zouden hebben, zouden we vijf variabelen kunnen maken.
‫Maar wat als we iets hadden dat onvoorspelbaar veel is, zoals het aantal acteurs dat we op
‫ons A-niveau hebben, of de acteurs die overlappen met een bepaald triggervolume?
‫In dit geval moeten we een nieuw gegevenstype gebruiken dat een T-array wordt genoemd in Unreal en in feite een T-array van een
‫bepaald type.
‫Ook hier zien we deze punthaken die, zoals we eerder zeiden, tijdparameters voor het compileren zijn.
‫En deze keer nemen we opnieuw een type op dat ons vertelt welk type we een array kunnen opslaan.
‫Een array is als een variabele, behalve dat het meerdere vakken heeft en het aantal vakken dat we hebben
‫kan verschillen.
‫Als we een spelletje spelen.
‫Het kan veranderen.
‫We kunnen meer of minder toevoegen naarmate we door het spel gaan, als dingen beginnen te overlappen met meer vakken toevoegen, als
‫dingen de overlappende zone verlaten, nemen we ze weg.
‫En zoals ik al zei, dit is een parameter binnen deze.
‫Punthaken.
‫En dus zouden we bijvoorbeeld een T-array van ints kunnen hebben, die verschillende gehele getallen in die vakken
‫zou opslaan.
‫We zouden een hele reeks acteursaanwijzers kunnen hebben, en dit zou de aanwijzers in de vakken opslaan, die
‫zouden verwijzen naar acteurs in de wereld.
‫En zoals je kunt zien, kunnen ze elkaar zelfs overlappen, zodat sommige van deze aanwijzingen naar dezelfde acteurs wijzen.
‫Nu oefenen dat zou niet erg handig zijn, maar het is zeker mogelijk.
‫Dus ik wil de documentatie van de primitieve component opnieuw bekijken, want wat
‫ik hier zoek, is een functie met de naam overlappende acteurs ophalen.
‫En als je kijkt naar de functie 'Overlappende acteurs ophalen', daar zijn een aantal versies van.
‫Maar degene die voor mij het meest interessant is, is de tweede.
‫Het heeft geen retourwaarde.
‫Het is een ongeldige retourwaarde.
‫Maar je kunt zien dat de eerste parameter hier een reeks actor-pointers is met een ampersand aan het einde, wat
‫betekent dat dit hele ding een verwijzing is naar een t-array.
‫Merk nu op dat het geen constante referentie is.
‫We kunnen dus aannemen dat deze parameter eigenlijk een out-parameter is.
‫Het geeft ons het resultaat van de overlappende actoren en het vertelt ons welke actoren momenteel overlappen
‫met onze primitieve componenten.
‫Nu is het zo dat onze dooscomponent een primitieve component is.
‫Dus onze triggercomponent is ook een projectcomponent en ik zou toegang hebben tot deze functie.
‫Er is hier nog een tweede argument, maar daar hoeven we ons geen zorgen over te maken, want het heeft eigenlijk
‫een standaardwaarde als we het gebruiken.
‫Dus laten we doorgaan en proberen een reeks actieve wijzers te bemachtigen en in te vullen.
‫We gaan in op de truccomponent, CPP.
‫We gaan naar de tick-componenten.
‫En hier gaan we een lege t-array maken die we kunnen vullen met deze functie.
‫Dus de syntaxis is t array open punthaken een acteurster om te zeggen dat we een t array van actoraanwijzers hebben,
‫sluit de punthaken en dan kunnen we deze variabele een naam geven als actoren.
‫Dan zouden we bellen om overlappende acteurs te krijgen en we zouden passeren in de acteursreeks.
‫Nutsvoorzieningen.
‫Ik weet niet waarom ze dit niet gewoon doorgeven als een retourwaarde, maar.
‫Daar ga je.
‫Het geeft ons de mogelijkheid om die onze parameters een beetje meer te gebruiken.
‫Nu, dat is allemaal goed en wel.
‫We hebben een aantal acteurs in een array.
‫Ze hebben een variabele lengte.
‫Het kunnen er nogal wat zijn.
‫Er kan nul zijn.
‫Wat doen we met dergelijke arrays?
‫Welnu, we kunnen opvragen hoeveel items zich in de array bevinden.
‫U kunt array dot num haakjes gebruiken en dat kan een geheel getal retourneren dat u vertelt hoeveel items zich in de array
‫bevinden.
‫Dus in deze specifieke array zouden we kunnen zeggen dat er vijf zijn, en dan hebben we toegang tot de items
‫binnen die array door deze vierkante haken te gebruiken.
‫En dan vertelt het nummer dat u tussen de vierkante haken doorgeeft, welk item u moet krijgen.
‫En het is een gebruikelijke conventie in veel programmeertalen dat we in arrays vanaf nul beginnen te tellen.
‫Dus het nulde element van een array is het eerste, het ene element van een array is het tweede, enz.
‫En dus eindig je met het laatste element dat altijd één minder is dan het aantal elementen in de array.
‫Dus hoe kunnen we deze kennis gebruiken?
‫We kunnen bijvoorbeeld de overlappende acteurs alleen afdrukken als er meer dan één is.
‫Dus hoe zouden we dit doen?
‫We zouden een if-statement plaatsen dat zegt dat als de acteurs punt aantal haakjes groter is dan nul, we hier iets kunnen doen, zoals toegang krijgen
‫tot het nul-element van onze acteurs, omdat we weten dat als het groter is dan nul, er moet zijn
‫op daar zit tenminste één element in.
‫Dus de nulde elementen van deze array moeten iets bevatten.
‫We konden niet garanderen dat het eerste element, het ene element van de array iets in heeft of het
‫twee element iets in heeft.
‫We zouden moeten controleren of we genoeg items in de array hebben om dat te doen, maar we weten
‫zeker dat hier de eerste is.
‫Dus laten we je uitdagen om de eerste overlappende actor uit die array af te drukken.
‫Gebruik de array om de aanwijzer te krijgen met behulp van die vierkante haken.
‫Dan ga je die aanwijzer gebruiken om te bellen, acteur, naam of label te krijgen, en dan ga
‫je dat uitprinten.
‫Pauzeer de video en probeer het.
‫Oké.
‫Welkom terug.
‫Dus we kunnen krijgen dat we de aanwijzer hier hebben gekregen met behulp van deze vierkante haken.
‫En ik ga dan meteen de naam te pakken krijgen door de pijl-operator te gebruiken en get actor,
‫naam of label te bellen.
‫En ik ga dat in een F-tekenreeksvariabele plaatsen met de naam acteur.
‫Dan gaan we een U-log maken, die we de overlappende dubbele punt gaan noemen.
‫En dan procent s.
‫En dan zou het tweede argument hier een asterisk moeten zijn, de naam van de acteur.
‫Dan kunnen we opnieuw compileren, in onze output log docket springen in de lay-out.
‫Dan gaan we de geheime muur van BP openen, want ik wil niet deze string afdrukken die dingen in
‫de war brengt.
‫In Blueprint doen we dit nu vanuit C++, dus laten we overgaan naar het hitspel op kerkerniveau.
‫En natuurlijk overlapt niets die acteur op dit moment.
‫Dus wat gebeurt er als we naar binnen gaan?
‫Je kunt zien dat het meteen begint te printen, dat we de BP-speler overlappen.
‫Fantastisch spul.
‫Wat als we in plaats daarvan de waterspuwer zouden gaan halen?
‫Breng het naar de alkoof, steek het erin en klaar.
‫Hij zegt dat het het beeld van de waterspuwer overlapt.
‫Goed spul.
‫We hebben dus geleerd hoe we een t-array kunnen gebruiken om een lijst met acteurs te krijgen en om uit te vinden hoeveel dingen
‫in die lijst staan en hoe we een bepaald item uit die lijst kunnen bemachtigen.
‫In de volgende lezing gaan we kijken naar enkele programmeerstructuren die ons in staat
‫stellen om te gaan met variabele aantallen dingen om een variabel aantal taken uit te voeren.
‫Ik zie je daar.