‫Hallo en welkom.
‫In deze lezing gaan we lidfuncties introduceren en een veilige en normale functie
‫krijgen waarmee we de richting van een bepaalde vector kunnen bepalen.
‫Laten we erin duiken en kijken hoe dit werkt.
‫Dus onze eenvoudige methode om het platform in de tegenovergestelde richting terug te sturen, werkt met de snelheden
‫waarmee we het hebben getest.
‫Maar wat gebeurt er als ik zeg: Hé, laten we dit platform tien keer sneller laten gaan?
‫Laten we doorgaan en spelen en zien wat er gebeurt.
‫Welnu, plotseling springen die platforms behoorlijk naar voren en zweeft het niet rond dezelfde locatie
‫als voorheen.
‫En de reden hiervoor is dat de huidige locatie, wanneer we deze instellen als de startlocatie, niet per
‫se precies de verplaatste afstand is.
‫We hadden kunnen overschrijden en dat is hier vastgelegd in het if-statement.
‫We zeggen dat de verplaatste afstand groter is dan de verplaatsingsafstand, wat betekent dat we voorbijgeschoten zullen
‫zijn.
‫We moeten een overschrijding hebben gedaan om dit if-statement te activeren.
‫Maar de vraag is met hoeveel?
‫En dat zal erg afhangen van hoe groot de Delta-tijd is.
‫We kunnen met vrij grote hoeveelheden doorschieten, vooral als de platformsnelheid groot is, wat betekent dat onze
‫startlocatie in de loop van de tijd kan afdrijven.
‫Het blijft misschien niet constant.
‫Dus de betere manier om dit te doen zou zijn om te berekenen hoe ver we van de oorspronkelijke startlocatie moeten gaan
‫om bij de nieuwe te komen met behulp van de exacte verplaatsingsafstand.
‫Dus laten we proberen deze heen en weer berekening te visualiseren.
‫We zeggen dat we hier een platform hebben op de startlocatie.
‫We zeggen dat het een snelheid heeft die we kunnen weergeven met een pijl die een richting en een grootte heeft, en het
‫heeft ook een afstand die we willen dat het beweegt, wat wordt weergegeven door deze accolade hier.
‫Wat we nu zeggen, is dat we het exacte punt willen uitvinden waar het platform aan
‫het einde zal zijn, niet voorbijgeschoten, maar precies de eindlocatie.
‫De manier waarop we dit kunnen doen is door de richting van die snelheidspijl te nemen.
‫Dus in vectortaal wordt dit de normaal van de pijl genoemd, en het komt er in feite op neer dat het
‫een maat is.
‫Dus we krijgen de richting maar een maat van één.
‫Dus dat stelt ons in staat om deze telling te weten, in wezen de grootte van de snelheid, hoe snel we gaan.
‫En wat we dan kunnen doen is die richting vermenigvuldigen met de hoeveelheid van onze afstand om ons een
‫pijl te geven die ons de hele beweging van de startlocatie naar de eindlocatie geeft.
‫Precies.
‫Laten we dus eens kijken hoe we dit in C++ kunnen doen.
‫Wat we zoeken is een nieuwe startlocatie.
‫Dus laten we verwijderen hoe we dit momenteel doen en we gaan een startlocatie hebben die gelijk is aan, nou ja, waar gaat
‫het gelijk aan zijn?
‫Het zal gelijk zijn aan, ten eerste, de startlocatie plus iets, omdat we vanaf
‫hier beginnen en we voegen deze groene vector toe om bij het einde te komen.
‫Dus wat is die groene vector daar?
‫Wel, dat is waar we de normaal van de platformsnelheid moeten krijgen.
‫En om het voor ons gemakkelijker te maken om het te begrijpen, ga ik dat opsplitsen in zijn eigen variabele.
‫Dus we gaan een heel nieuwe type effector maken, die ik de bewegingsrichting ga noemen, gewoon om
‫het superduidelijk te maken wat we erin proberen op te
‫slaan en dan gaan we naar haal dit van de platformsnelheidspunt, ga veilig, normaal en dan wat haakjes rond het einde.
‫Dus wat is hier aan de hand?
‫Dit hebben we nog niet eerder gezien.
‫We hebben punten gebruikt om de componenten van de vector, de X, Y en Z, te bemachtigen.
‫Dat waren variabelen.
‫Maar in C++ en in objectgeoriënteerd programmeren in het algemeen, hebben we ook functies die in klassen bestaan, dus we
‫kunnen de DOT-operator gebruiken om er een te bemachtigen.
‫We hebben de dubbele punt gebruikt toen we probeerden het uit de klas zelf te krijgen.
‫Maar als we een bewerking willen uitvoeren met de eigenlijke vector zelf, dus platformsnelheidsvector, kunnen we de
‫puntoperator gebruiken om de normaal van de gebonden vector te krijgen.
‫Dus dat is wat we hier doen, met behulp van een lidfunctie in plaats van een lidvariabele.
‫Dus we hebben de veilige normaal van die platformsnelheid en puntkomma, het einde van de regel, want hier hebben
‫we een variabele waarvan we in wezen zeggen dat dit de bewegingsrichting is.
‫Dus nu kunnen we dat in de volgende regel gebruiken om een verplaatsingsrichting te doen vermenigvuldigd met de verplaatsingsafstand
‫die is geconfigureerd omdat we precies naar het einde willen gaan, niet voorbijschieten.
‫En nadat we dat hebben gedaan, zouden we ons platform eigenlijk naar de eindlocatie moeten verplaatsen.
‫Dus we gaan een vaste acteurslocatie doen als startlocatie, omdat ons platform anders voorbij die eindlocatie is geraakt
‫en voorbij die eindlocatie is gegaan omdat we het hebben bijgewerkt met de huidige locatie, wat
‫de overshotlocatie is.
‫Zodat we precies naar het eindpunt kunnen gaan.
‫En dan starten vanaf die nieuwe startlocatie.
‫Nu is het belangrijk dat we de platformsnelheid bijwerken nadat we dit allemaal hebben gedaan, omdat we
‫het gebruiken om de bewegingsrichtingen te verkrijgen.
‫Ik ga de platformsnelheid updaten nadat we de acteurslocatie hebben ingesteld.
‫Laten we nu teruggaan naar Unreal en op compileren drukken en kijken of dit is opgelost.
‫Het probleem met ons platform dat heen en weer beweegt.
‫Laten we deze terminal sluiten en op play drukken.
‫En als we nu kijken, het platform beweegt snel, maar beweegt betrouwbaar rond de begin- en
‫eindlocatie, zouden we verwachten.
‫Dus dat is alles wat ik wilde bespreken in deze lezing, en dat is correct.
‫Een klein foutje dat zich had kunnen voordoen bij sommige van onze platformconfiguraties.
‫Ik zie wel in de volgende.