‫Hallo en welkom terug.
‫Nu zijn we klaar om het torentje te draaien en we zouden dit graag doen met de muis.
‫En die trefferlocatie van de treffer die we in de vorige video hebben gedaan.
‫Dus terwijl ik mijn muiscursor beweeg, roteert het torentje en wijst het in de richting van de muiscursor.
‫En zelfs als ik in de viewport klik en begin te spelen, kan ik de muiscursor nog steeds verplaatsen om de
‫toren te draaien en de richting ervan in te stellen.
‫Hierdoor kan ik richten als ik de mogelijkheid heb om projectielen af te vuren.
‫Oké.
‫Dus om dit te bereiken, moeten we de richting vinden waarin we willen dat onze toren wijst.
‫En als we die richting eenmaal hebben gevonden, kunnen we de rotatie van het torentje instellen.
‫Om de richting te krijgen waarnaar we willen dat de koepel wijst, moeten we een beetje
‫vectorwiskunde doen.
‫Wat we zoeken is een vector van de tankkoepel naar onze traceerlocatie.
‫Nu kunnen we gemakkelijk de locatie van onze tank of een van zijn componenten achterhalen, zoals de locatie van de toren
‫van de tank.
‫We noemen deze locatie, torentje, locatie.
‫En we weten ook hoe we de locatie van de traceerkop kunnen achterhalen.
‫We noemen dit de locatie van de treffer.
‫Waar we in geïnteresseerd zijn, is de vector van de locatie van de toren tot de locatie van de treffer.
‫We noemen deze vector om te richten.
‫Nu is de vectorwiskunde om het doel te bereiken eigenlijk vrij eenvoudig.
‫Om een vector van een startpunt naar een eindpunt te krijgen is altijd het eindpunt minus het startpunt.
‫Dus als we onze tracering nemen, de locatie raken en de locatie van de vectortoren aftrekken, dan is
‫de vector die hieruit voortvloeit het doel.
‫Nu we de twee doelrichtingsvectoren hebben, willen we die omzetten in een rotatie, zodat we de
‫rotatie van de tankkoepel kunnen instellen.
‫En het vectortype heeft een ingebouwde functie die rotatie wordt genoemd.
‫Dus als we onze doelvector zouden nemen en er rotatie op zouden noemen, zou dit een F-rotator opleveren die overeenkomt met
‫die richting.
‫Nu moeten we wel iets in het achterhoofd houden.
‫Het resultaat van de spoorslag zal vaak op de vloer zijn en de vector van de tankkoepel naar het resultaat
‫van de spoorslag zal niet parallel zijn met de grond.
‫Dit betekent dat als we de rotatie van de tank naar de rotator instellen, we uit die richtingsvector krijgen, we iets
‫als dit kunnen krijgen waarbij de toren naar beneden gericht is naar de grond, maar we willen niet dat
‫de toren van de tank naar beneden draait.
‫We willen dat het nog steeds naar voren wijst.
‫Dit is dus het resultaat dat we willen.
‫Met andere woorden, we willen alleen de ja-component van de rotatie van de tankkoepel veranderen.
‫Dus op die manier wijst het in de juiste richting, maar blijft toch evenwijdig aan de grond.
‫We hebben alleen de gier veranderd, dus laten we teruggaan naar de VS-code en een functie maken voor het draaien van de
‫tankkoepel.
‫Nu gaan we het torentje op de tank draaien, maar we willen ook het torentje op
‫onze torenvijand draaien en de toren zal binnenkort worden gemaakt afgeleid van base pon, wat betekent dat als we een roterend
‫torentje maken functie kunnen we het hier in de basis pong-klasse plaatsen.
‫Dus op die manier zullen zowel de tank als de toren deze functie erven.
‫Omdat we van plan zijn het in zowel de toren als de tank te gebruiken, kunnen we deze functie beschermen.
‫Dus ik ga een beveiligde sectie toevoegen en alle functies en variabelen die we in de beschermde
‫sectie plaatsen, zijn toegankelijk in deze onderliggende klassen, maar niet in andere klassen.
‫Het is dus bijna net zo beperkt als privévariabelen.
‫Nu kan deze functie void retourneren.
‫Ik noem dit een roterend torentje.
‫En om de toren te draaien, heb ik een soort bestemming nodig om naar te kijken.
‫Dit kan een f-vector zijn en we kunnen dit blik op doel noemen.
‫Dus het idee is dat als we een functie hebben die we kunnen passeren op een of andere locatie in de wereld, de functie
‫zou moeten resulteren in het draaien van de toren naar die locatie.
‫Dus laten we doorgaan en een functiedefinitie geven voor het draaien van de turret.
‫Dus hier in de basispion CP, net onder de constructor, ga ik een roterend torentje implementeren.
‫En natuurlijk heb ik de naam van een basispionklasse nodig met de scope-resolutie-operator hier.
‫Dus nu ik een geroteerd torentje heb, laten we nadenken over hoe we dit gaan implementeren.
‫Het eerste dat we nodig hebben, is dat om de vector van de torencomponent te richten op het resultaat van
‫de traceertreffer onder de muiscursor.
‫Dit kan dus een lokale F-vector zijn die naar het doel wordt geroepen en we gaan het gelijk stellen aan het resultaat van
‫wat vectorwiskunde.
‫Onthoud dat dit de bestemming wordt minus het startpunt.
‫En de bestemming is kijken naar het doel en het startpunt wordt de locatie van de toren van de tank, met andere
‫woorden, de locatie van het gaas van de toren.
‫Dus we kunnen turret mesh zeggen en we kunnen de locatie van de turret mesh krijgen.
‫De manier om de wereldlocatie van een component te krijgen, is met deze functie componentlocatie ophalen.
‫Het behoort tot de klasse use scene component.
‫Dus alle scènecomponenten hebben het.
‫Dus vanuit de turret mesh noemen we de locatie van de component.
‫Dus kijk naar het doel minus de locatie van het torentje en geeft ons de vector van het torentje naar het
‫uitkijkdoel.
‫Nu, zoals ik al zei, kunnen we een EF-rotator van naar doel krijgen met behulp van de F-vectoren-rotatiefunctie.
‫Dus we gaan een F-rotator maken en we kunnen dit een kijk op rotatie noemen en
‫we stellen dit gelijk aan de doelpuntrotatie.
‫Dat is een functieaanroep.
‫Dus nu hebben we de rotator die hiermee overeenkomt met de doelrichtingsvector.
‫Maar het punt is dat we alleen om de YA geven.
‫We willen de toonhoogte of rol niet veranderen.
‫We willen de toren alleen rond de z-as draaien en parallel aan de grond houden.
‫Nu kunnen we dit op verschillende manieren doen.
‫Ten eerste kunnen we kijken naar rotatie, toonhoogte en dat op nul stellen.
‫Met andere woorden, stel het gelijk aan nul.
‫We kunnen ook kijken naar de rotatiepuntrol en die ook op nul zetten.
‫Nadat we pitch en roll op nul hebben gezet, hebben we de rotatie die we willen, wat alleen het onderdeel is.
‫Dit is een manier om het te doen.
‫Een andere mogelijkheid is om een van de F-rotatorconstructor-overbelastingen te gebruiken.
‫Als we f rotator tussen haakjes zeiden en een aantal waarden doorgaven, zoals nulpunt F voor de eerste en de pop-up vertelt
‫me dat die eerste invoer de toonhoogte is.
‫En dan voor de ya die we kunnen gebruiken om rotatie te richten.
‫Ja.
‫En voor de rol zouden we nulpunt F kunnen gebruiken.
‫Wat dit nu doet, is een nieuwe F-rotator creëren met nul voor de toonhoogte, nul voor de rol en de component
‫van de rotator die wordt geretourneerd door twee doelrotaties.
‫Dus de waarde die hierdoor wordt geretourneerd, zou ons hetzelfde resultaat geven als wat we hier met deze drie regels hebben gedaan.
‫Dus aangezien dit een beetje compacter en eleganter is, denk ik dat ik dit liever gebruik, zodat
‫we de kijk op rotatievector kunnen initialiseren met de F-rotator geretourneerd door de F-rotatorconstructor op deze manier aan te roepen.
‫Dus ik ga deze regel hier beneden verwijderen.
‫En nu kijken we naar rotatie.
‫Het laatste dat u in deze functie hoeft te doen, is de rotatie voor de revolverpuree in te stellen.
‫Nu kunnen we de rotatie voor een bepaalde component opnieuw instellen met behulp van deze functie set wereldrotatie, het hoort bij
‫het gebruik van scene component.
‫En de reden dat we vaste woordrotatie gebruiken in plaats van een soort lokale rotatieoffset
‫toe te voegen, is omdat we een rotatie hebben in wereldruimte twee. Het doel is een wereldruimterichtingsvector.
‫We nemen de locatie van het torentje in de wereldruimte en trekken de blik op de doellocatie in de
‫wereldruimte af.
‫Dit is dus een richting van de wereldruimte.
‫Daarom is de kijk op rotatie een rotatie van de wereldruimte.
‫Dus we gaan set wereldrotatie gebruiken op het torentje mesh.
‫Dus we zeggen turret mesh, stel wereldrotatie in en we gaan kijken naar rotatie.
‫Dus nu hebben we een functie die elk doelwit in de wereld kan nemen en het torennet kan draaien om ernaar te
‫kijken, maar het zal het gaas niet naar beneden draaien.
‫Hij verandert alleen zijn gier, dus hij draait op een manier zoals een tankkoepel zou moeten draaien.
‫Dus we hebben nu een functie om de toren te draaien.
‫Ik daag je uit om deze functie aan te roepen om die torenrotatie in te stellen, de draaitorenfunctie in
‫de tankklasse aan te roepen.
‫Dit is een beveiligde functie.
‫Dus de tankklasse heeft er toegang toe.
‫Nu draait het torentje een F-vector, de blik op het doel, je gaat dat impactpunt gebruiken in
‫het F-trefferresultaat van onze lijntracering.
‫Dus ik laat het aan jou over om de juiste plaats in de code te vinden om deze functie aan te roepen.
‫Dus pauzeer de video en plaats de draaitorenfunctie.
‫Bel in de tankklasse.
‫Oké.
‫Dus we hebben onze draaitorenfunctie en we zijn klaar om het te noemen.
‫Ik ga de tank in en hier is mijn vinkfunctie in de if-check voor spelercontrollerref.
‫Ik heb mijn hitresultaat en nadat een get hit-resultaat onder de cursor is aangeroepen, heeft het hitresultaat
‫geldige gegevens.
‫In feite gebruiken we dat impactpunt van het trefferresultaat en tekenen we een debug-bol.
‫Nu ik de debug-bol niet meer hoef te tekenen, ga ik door en verwijder die.
‫En in plaats daarvan ga ik onze beschermde functie 'rotatietorentje' noemen.
‫En voor de blik op het doel, ga ik het punt van het slagresultaat doorgeven.
‫Dus nu gaan we bij elk frame de toren naar dat inslagpunt draaien vanuit ons hitresultaat.
‫Voordat ik dit compileer, gebruik ik niet langer draw-debug-helpers, dus ik ga door en verwijder
‫dat header-bestand.
‫Oké.
‫Nu ben ik klaar om te compileren.
‫Oké.
‫Ik ben weer hier in de editor.
‫Laten we doorgaan en op play drukken en het bekijken.
‫Dit is geweldig.
‫Ik kan nog steeds ronddraaien.
‫Ik kan mijn muis bewegen en het torentje draait overal waar ik mijn muiscursor beweeg.
‫Dit is dus geweldig.
‫Oké, dus voordat we dit afronden, wil ik een paar problemen bespreken.
‫Ik wil dat dit mooi en gepolijst is en er geweldig uitziet.
‫Nu doet het eerste probleem zich voor wanneer ik de muiscursor dicht bij het midden van de tank beweeg en er
‫vervolgens doorheen ga.
‫Je zult zien dat die rotatie op een gegeven moment heel snel klikt.
‫En als we de muis een beetje op een lukrake manier verplaatsen, nou, dat ziet er niet zo goed uit.
‫Het knapt.
‫We hebben geen vloeiende bewegingen.
‫Dus dat is één probleem.
‫Het andere probleem is dat als ik klik en ik rol en naar de rand ga, ik zal zien dat mijn torentje
‫in de andere richting springt als ik mijn muiscursor omhoog beweeg.
‫Dus wat is daar aan de hand?
‫Nou, laten we het uitzoeken.
‫We gaan terug naar VS-code en ik zou graag mijn debug-bol terug willen krijgen.
‫Dus hier in Tank, ga ik naar de tick-functie vlak voor het draaien van de turret
‫en nogmaals ga ik debug debug sphere aanroepen.
‫Nu voor de wereld die ik passeer, haal de wereld voor het midden Ik passeer het resultaat van
‫de treffer Dot-inslagpunt voor de straal Ik gebruik 25 stip F-segmenten kunnen 12 zijn, kleur kan F zijn kleur rood aanhoudende lijnen kunnen
‫onwaar zijn en levensduur kan negatief zijn.
‫Dus hetzelfde als wat we eerder deden.
‫Ik ga dit bericht dus bewaren.
‫Ik voeg het header-bestand daar niet opnieuw toe en dat komt omdat debug-helpers eigenlijk standaard zijn inbegrepen, dus we
‫hebben het technisch niet nodig.
‫Ik ga gewoon opslaan, spring terug in de editor, doe een live codering kickoff en druk op play.
‫Dus nu heb ik mijn debug-sfeer.
‫Dus laten we naar de rand van de wereld gaan en ik ga die muiscursor naar de plek brengen waar
‫hij in de afgrond valt.
‫En daar hebben we het probleem.
‫Zie je, we hebben geen trefferresultaat onder de cursor wanneer onze cursor daar omhoog beweegt, omdat er niets
‫is waar we een trefferresultaat van kunnen krijgen.
‫Daarom is ons impactpunt niet gedefinieerd.
‫Dus wat we nodig hebben is iets om dat lijnspoor te raken.
‫Nu heeft Unreal Engine veel tools die we kunnen gebruiken.
‫Wat ik ga doen, is op de vervolgkeuzelijst hier klikken en het paneel van mijn plaatsacteur openen en dit pictogram
‫selecteren dat volumes zegt en een blokkerend volume krijgen.
‫Hier is het blokkeren van het volume.
‫Ik sleep er een naar binnen.
‫Dus nu heb ik dit blokkeervolume.
‫Standaard worden blokkerende volumes verondersteld onzichtbaar te zijn.
‫Als ik hiervoor naar het detailvenster ga en naar de botsing scrol, zie ik
‫dat het Collision Presets is Invisible Wall, wat lijkt te suggereren dat het bijna alles zou moeten blokkeren.
‫Het enige dat het niet blokkeert, is het zichtbaarheidskanaal en onze lijntracering
‫volgt toevallig het zichtbaarheidskanaal.
‫Alles in onze wereld dat het zichtbaarheidskanaal blokkeert, wordt geraakt door onze lijntracering.
‫Maar dit specifieke volume niet.
‫Het hoort onzichtbaar te zijn.
‫Welnu, we kunnen naar de voorinstellingen voor botsingen gaan, de vervolgkeuzelijst openen en aangepast selecteren.
‫Hierdoor kunnen we dat veranderen, zodat ik de botsingsreactie op het zichtbaarheidskanaal kan instellen.
‫Het is een blok.
‫Dus nu heb ik een onzichtbaar volume, maar het is ingesteld om het zichtbaarheidskanaal te blokkeren, wat
‫betekent dat lijnsporen die tegen het zichtbaarheidskanaal aanlopen, zoals het onze, het zullen raken.
‫Dus wat ik kan doen, is dat ik dit blokkerende volume kan nemen en het kan opschalen.
‫Ik zal het net buiten de muur plaatsen.
‫Ik kan het zelfs hier aan de rand van de muur plaatsen, en ik zal het een beetje naar beneden brengen
‫zodat het een beetje overlapt met de muur.
‫En op die manier hebben we hier deze onzichtbare barrière, en ik ga door en schalen het ook
‫op in de Y-richting.
‫Dus ik zal dat mooi en groot krijgen en het hier in het midden plaatsen en het een beetje opvulling geven.
‫En ik ga het ook opschalen in de Z-richting.
‫Dus nu is het mooi groot en onze lijntracering zou het moeten raken.
‫Dus laten we die theorie testen.
‫Laten we in de viewport klikken en naar de muur gaan.
‫En ja hoor, ik raak dat blokkerende volume met mijn lijntracering en ik heb niet dat probleem waar
‫mijn torentje klikt om naar een ongedefinieerde locatie te kijken.
‫Het kijkt waarschijnlijk naar de oorsprong van de wereld omdat die vector van het inslagpunt allemaal nullen is.
‫Als ik nu naar deze muur ga, heb ik hetzelfde probleem.
‫Dus we hebben deze blokkerende volumes nodig.
‫Rondom de omtrek van ons niveau.
‫Nou, dat kan best makkelijk zijn.
‫Het enige wat ik hoef te doen is dit blokkeervolume dupliceren.
‫Nu kan ik van perspectiefweergave naar orthografische topweergave wisselen.
‫Dus ik ga naar boven selecteren en naar buiten scrollen met mijn muiswiel en gewoon alt ingedrukt houden en deze muur dupliceren
‫en er een hier plaatsen en ik kan op E drukken om naar de roteermodus te gaan.
‫Dus ik ga alt vasthouden en 90 graden draaien.
‫Dat geeft me een kopie en dan druk ik op dubbel u en zet ik mijn vertaalmodus aan de gang en
‫ik verplaats hem hier naar deze kant en houd Alt ingedrukt en sleep een kopie naar die kant.
‫Dus nu hebben we vier muren.
‫Nu kan ik van bovenaanzicht terug naar perspectief en op play drukken, en nu kan ik naar een van deze muren
‫gaan en het maakt niet uit welke muur ik bedekt, dus dat ziet er geweldig uit.
‫Dus dat lost een van onze problemen op.
‫Maar hoe zit het met deze andere?
‫Als we de muis in de buurt van onze tank bewegen, hebben we nog steeds dit sporadische gedrag.
‫Dus daar wil ik ook voor zorgen.
‫De manier waarop ik hiervoor kan zorgen is door die rotatie te interpoleren.
‫Dus in plaats van deze rotatiewaarde rechtstreeks in te stellen, kunnen we een interpolatiefunctie gebruiken
‫die die rotatie in wezen op een soepele manier naar het doel verplaatst dat we bieden.
‫Dus laten we eens kijken hoe dat werkt.
‫Nu zou ik willen dat deze interpolatie in onze draaitorenfunctie zit, zodat we terug kunnen gaan naar
‫de basispion om de toren te roteren, en in plaats van onze wereldrotatie in te stellen zodat de toren naar
‫rotatie kijkt, kunnen we deze gelijk stellen aan de waarde die wordt geretourneerd door een interpolatiefunctie.
‫Dus ik ga verwijderen, kijk naar rotatie en in plaats daarvan gaan we een functie aanroepen
‫in de F-wiskundebibliotheek met de naam R inter twee.
‫Nu is onze in two ontworpen om interpolatie voor rotators aan te kunnen.
‫Nu is de eerste invoerparameter een const F-rotatorreferentie die stroom wordt genoemd.
‫Dat is de huidige waarde van het ding dat we proberen te veranderen.
‫Wat we proberen te veranderen, is de rotatie van onze torentjes en die kunnen we halen uit ons torentjegaas.
‫Dus we zeggen turret mesh en de functie die we willen gebruiken is componentrotatie krijgen.
‫Dus het lijkt veel op de locatie van de component, alleen krijgt het de rotatie.
‫Nu is de volgende invoer een F-rotator genaamd Target.
‫Dat is de waarde.
‫We willen dat deze turret mesh-rotatie wordt geïnterpreteerd om soepel te naderen.
‫Dat wordt onze kijk op rotatie.
‫Dus ik ga zeggen kijk naar rotatie.
‫De volgende invoer is Deltatijd.
‫Dus we kennen het belang van Delta-tijd.
‫Als we dingen verplaatsen of draaien, willen we dat die beweging onafhankelijk is van de framesnelheid.
‫Dus daarvoor kunnen we Delta-tijd krijgen.
‫Ik kan eenvoudig gameplay-statistieken opnemen en als je een goed geheugen hebt, zul je je herinneren
‫dat de opname kismet slash-gameplay-statistieken is.
‫Dus ik zal gameplay-statistieken hier krijgen, zodat ik toegang heb tot de statische functie, werelddelta-seconden kan krijgen en
‫onthoud dat dit een wereldcontextobject vereist.
‫Dus ik ga dit er in verwerken.
‫En als laatste hebben we een interne snelheid nodig.
‫Hoe hoger de waarde van de interne snelheid, hoe sneller we naar het doel zullen interpoleren.
‫Dus als ik dit instel op een waarde van bijvoorbeeld vijf F, dan interpoleren we vrij langzaam.
‫Laten we eens kijken hoe dit er nu uitziet.
‫Dit alles staat op één regel en loopt van het scherm af.
‫Dus wat ik ga doen is de invoer plaatsen om de wereldrotatie op zijn eigen regel in te stellen, zoals deze.
‫Dus gewoon zo.
‫En dan onze tolk, die deze vier invoerparameters ook van het scherm laat lopen.
‫Dus ik ga ze elk op hun eigen regels zetten.
‫Op die manier kunnen we alle invoer zien zonder zo van het scherm te hoeven scrollen.
‫Oke.
‫Ik ga door en sla dat op en start live codering.
‫En als ik nu op play druk en de muis beweeg, merk dan op dat het even duurt voordat die rotatie
‫plaatsvindt.
‫Dat komt omdat we soepel interpoleren naar die doelrotatie.
‫Dit is geweldig.
‫Dat is precies wat ik wilde.
‫Hoe ik mijn muis ook beweeg, ik krijg nooit die pittige, schokkerige, sporadische beweging.
‫Nu is vijf een erg lage internetsnelheid, maar daar kunnen we verandering in brengen.
‫We kunnen het een beetje sneller maken.
‫Ik ga dit instellen op 25, kijken hoe dat eruit ziet, en ik laat je doorgaan en beslissen over de waarde die je
‫leuk vindt voor je spel.
‫Dus nog een keer, live coderen en op play drukken.
‫Nu heb ik een vrij snelle interpolatie, maar het klikt niet.
‫Het is nog steeds snel, maar het is geen momentopname.
‫Dus zolang we zoiets niet doen, nou, dat krijgen we niet.
‫Gek gedrag.
‫En natuurlijk, als je een langzamere rotatie wilt, weet je nu hoe je het moet doen en we zijn klaar met
‫de debug-bol tekenen, dus ik zal doorgaan en dat verwijderen.
‫Oké.
‫Samenvattend, we hebben de rotatie van de koepel ingesteld en kijken naar Target, een F-vector die
‫overeenkomt met een punt in de wereld.
‫Op dit moment gebruiken we alleen het resultaat van de traceertreffer.
‫Nu hebben we deze functie in de base pong-klasse geplaatst en beveiligd, wat betekent dat
‫we de functie in de tankklasse konden erven.
‫En als we eenmaal klaar zijn om een torenklasse te maken op basis van basis --, dan zal die torenklasse deze
‫functie voor het draaien van torentjes erven en kunnen we deze opnieuw gebruiken.
‫Het enige wat we hoeven te doen is passeren.
‫In een nieuwe kijk op Target zullen we in de komende lezingen werken aan het creëren van een torenklasse die is afgeleid
‫van basis.
‫Ik zie je snel.