‫Hallo en welkom terug.
‫Nu hebben we beweging voor de --, maar we draaien niet dat bovenste deel van de --, dat we de
‫toren noemen.
‫Dus we willen dat graag met onze muis kunnen doen.
‫Kijk nu eens wat hier aan de hand is.
‫Terwijl ik mijn muiscursor over de wereld beweeg, krijg ik deze rode bol.
‫Dit is een debug-bol die ik in 3D-ruimte teken.
‫Merk nu op dat als ik tegen een muur opga, die bol tegen het oppervlak van de muur beweegt.
‫Dus waar mijn muiscursor ook beweegt, ik krijg een angst die overeenkomt met welk object ik
‫ook raak op basis van mijn cursorlocatie.
‫En dit zal nuttig voor ons zijn, zodat we een locatie in de ruimte kunnen hebben waar we onze toren naartoe
‫kunnen draaien.
‫Om dit te doen, zijn er enkele functies die we nodig hebben op de controller, dus we moeten toegang krijgen tot
‫die functies op de controller.
‫En in deze video gaan we eraan werken om dat in te stellen en we gaan ook bespreken hoe
‫dit een concept met zich meebrengt dat bekend staat als casting.
‫De reden dat we de controller willen, is omdat er functies op de controller zijn waarmee we
‫het hitresultaat onder de cursor kunnen krijgen.
‫Nu hebben we het over de muiscursor.
‫Dus stel dat dit ons scherm is en hier onze muiscursor.
‫En het punt op de punt van de cursor komt overeen met een locatie op het scherm.
‫Als we nu de cursor verplaatsen, is ons doel dat het torentje van onze tank, dat bovenste
‫deel van ons gaas, gaat roteren zodat het in de richting van die cursor wijst.
‫Als we nu de cursor verplaatsen, is er een functie op de controller die we kunnen gebruiken om de locatie
‫te krijgen die overeenkomt met die cursor.
‫Als we een lijn rechtstreeks vanuit de camera naar de cursor zouden trekken en een object in
‫de wereld zouden raken, kunnen we die locatie krijgen en die locatie gebruiken om de rotatie voor de tankkoepel in te stellen.
‫Laat me je laten zien wat ik bedoel.
‫Nu, om deze hitlocatie te krijgen die overeenkomt met onze cursor, moeten we de controller gebruiken.
‫Laten we het nu even hebben over de controller.
‫Laten we zeggen dat we onze pion in de wereld hebben.
‫Een pion heeft een controller.
‫Dit is een onzichtbaar object dat bij de pion hoort.
‫Nu, voor onze pion, zal onze controller het type A-spelercontroller hebben en aan het begin van
‫het spel zal de controller de pion bezitten.
‫Dit is waarom we kunnen zien vanuit het oogpunt van de camera die bij onze piontank hoort.
‫Nu hebben we toegang tot deze controller.
‫Onze tankklasse erft een functie genaamd Get Controller.
‫Het is geërfd van de klasse --.
‫Dus wat we zouden willen doen, is die controller te pakken krijgen en die in een variabele opslaan, zodat we deze kunnen gebruiken om toegang
‫te krijgen tot de functie die we nodig hebben om het hitresultaat onder de cursor te krijgen.
‫Laten we ons daar dus op voorbereiden.
‫Nu ben ik hier in de tankklasse en de plaats waar we toegang moeten krijgen tot onze controller is beginnen met spelen.
‫Als we het in de constructor doen, is dat te vroeg en hebben we misschien nog geen geldige controller.
‫Dus we hebben de begin-afspeelfunctie nodig hier in de tankklasse.
‫Nu hebben we het hier in de basispongklasse en tot nu toe gebruiken we beginspel niet echt in
‫de basispongklasse.
‫Dus wat ik zou willen doen is het naar de tankklasse verplaatsen.
‫Dus ik ga beginnen met spelen te markeren, inclusief het commentaar en het beschermde gedeelte hier en ik
‫ga het gewoon knippen.
‫En dan terug in de tankfase, ga ik het plakken.
‫Laten we dit beschermde gedeelte hier net boven het privégedeelte toevoegen met het spel binnenin.
‫Nu hebben we Begin Spelen van de basispion verwijderd.
‫We hebben het hier niet meer, maar we moeten het ook verwijderen uit basisvijver cpp.
‫Hier is het.
‫We kunnen doorgaan en het hier verwijderen en nu hebben we het hier gedeclareerd in Tank H, maar we moeten
‫het ook definiëren in tank CPP.
‫Dus ik ga de functie definiëren net onder de spelerinvoercomponent.
‫Dus het wordt ongeldig om te beginnen met spelen zonder invoerparameters.
‫Er is de functietekst en we hebben ook een tank nodig die de functienaam vooraf vastlegt.
‫Nu weten we dat het belangrijk is om super groot te noemen in het spel.
‫Dus op die manier zullen alle functionaliteiten in de start play-functie en alle bovenliggende klassen nog steeds worden
‫aangeroepen.
‫Dus hier moeten we beginnen met spelen.
‫Hier kunnen we onze controller ophalen en in een variabele opslaan.
‫Laten we dus teruggaan naar Tank H en een variabele maken.
‫Dit wordt nu privé en ik plak het hier
‫onderaan het privégedeelte en het wordt een spelercontroller-aanwijzertype en we kunnen deze spelercontroller ref noemen.
‫Dit zal onze verwijzing zijn naar de spelercontroller.
‫Nu hebben we het niet over een C++-referentie.
‫Dit is nog steeds slechts een aanwijzer, maar we gaan dit gebruiken om naar de spelercontroller te verwijzen.
‫Dus nu hebben we een spelercontroller ref-variabele van type A spelercontroller en we zijn klaar om de controller in
‫deze aanwijzer op te slaan.
‫Dus laten we hier teruggaan naar Tank Dot CP en beginnen met spelen en proberen dit te doen.
‫Dus.
‫Wat ik ga doen is zeggen speler, controller, ref is gelijk aan en ik ga proberen om get controller te bellen.
‫Krijg nu de controller, zoals ik al zei, is in de ---klasse.
‫Laten we met de rechtermuisknop klikken en naar de definitie gaan en zien dat deze functie een A-controller retourneert.
‫Nu is onze variabele van het type A-spelercontroller, geen controller.
‫Dus wat we hier proberen te doen, is de geretourneerde waarde van get controller te nemen, die van
‫het type controller-aanwijzer is en we proberen deze op te slaan in een A-speler-controller-aanwijzer.
‫Merk op dat we hier de rode kronkel zien.
‫Er staat een waarde van het type.
‫Een controller-pointer kan niet worden toegewezen aan een entiteit van het type.
‫Een spelercontroller.
‫We krijgen een foutmelding.
‫Laten we hier eens kijken naar de documentatie voor een controller.
‫Kijk eens.
‫Hier is een controleur.
‫En er staat overerving, hiërarchie.
‫En onder een controller zien we een a controller en een player controller.
‫Dit betekent dat een spelercontroller een onderliggende klasse is van een controller.
‫Nu kunnen we in C ++ geen aanwijzer van het type hebben.
‫Een spelercontroller slaat de waarde van het adres van een A-controller op.
‫Een controller is het bovenliggende type.
‫Een spelercontroller is het kindtype.
‫U kunt een object van het bovenliggende type niet nemen en opslaan in een aanwijzer van het onderliggende type.
‫Dus hoe komen we hier omheen?
‫Dus hier is ons probleem.
‫De functie get controller retourneert het adres van een A-controller.
‫Dit is iets dat we kunnen opslaan in een A-controller-aanwijzer, maar we kunnen het niet opslaan in
‫een A-speler-controller-aanwijzer.
‫Het grappige is echter dat het object dat wordt geretourneerd door de get-controller in feite een speler-controller is.
‫Dus we hebben dit adres in de vorm van een A-controlleraanwijzer en we weten dat het een spelercontroller is, maar als we het
‫in de vorm van een A-controller hebben, hebben we geen toegang tot de functie die we nodig hebben
‫omdat het op een spelercontroller bestaat .
‫De functie heet get hit resultaat onder de cursor.
‫Als we nu een waarde van type A controller-aanwijzer hebben en we proberen die functie te krijgen die bestaat op een spelercontroller,
‫zullen we er niet in slagen om dit te doen.
‫We krijgen een compilatiefout.
‫Dus omdat we weten dat het object zelf een spelercontroller is, is het gewoon opgeslagen in een A-controlleraanwijzer.
‫Hoe komen we om dit probleem heen?
‫Het antwoord is dat we moeten casten.
‫We weten dat een controller de bovenliggende klasse is en een spelercontroller de onderliggende klasse.
‫En we weten dat we geen A-controller kunnen opslaan in een A-speler-controller-aanwijzer.
‫We weten dat we de andere kant op kunnen gaan en een A controller pointer store hebben, een object van een
‫player controller.
‫Dat is in feite wat we zien als we get controller noemen, het retourneert een A-controller-aanwijzer
‫die naar een A-speler-controller wijst.
‫Dus als we een waarde van type A controller pointer hebben, kunnen we een speciale functie genaamd cast gebruiken om
‫het type pointer om te zetten in een A player controller pointer.
‫Dus casten verandert het type van de ene aanwijzer in een ander aanwijzertype, zolang het object zelf het type is waarnaar
‫we proberen te casten.
‫Als we nu bijvoorbeeld probeerden te casten naar een ongeldig type, hebben we een A-controller-aanwijzer die
‫naar een spelercontroller-object wijst.
‫Als we proberen een personage te casten, retourneert de cast-functie null en zeggen we dat we de cast niet
‫halen.
‫Dus de cast-functie ziet er als volgt uit.
‫Het is een sjabloon, net als het maken van een standaard subobject.
‫Deze sjabloonfunctie past zich aan het gekozen type aan en in deze functie is het type dat we doorgeven ook het
‫type dat we casten.
‫Dus dat type passeren we.
‫We willen er twee tussen de punthaken plaatsen en we geven de aanwijzer door die we tussen de haakjes
‫willen plaatsen.
‫Hier is een voorbeeld.
‫Laten we zeggen dat we willen casten naar een spelercontroller en een aanwijzer van het type A-controllertype.
‫We geven de aanwijzer door tussen haakjes en het type waarnaar we casten tussen de schuine haken.
‫En wat wordt geretourneerd, is een waarde van de aanwijzer van de spelercontroller van het type A.
‫Dus hier is de functieaanroep waarbij we het type tussen de punthaken doorgeven en
‫de A-controller-aanwijzerwaarde die we krijgen van get controller kan tussen haakjes staan.
‫We moeten dus deze waarde casten die we terugkrijgen van get controller.
‫Dat wordt jouw uitdaging.
‫Dus in Begin Play, gebruik de get-controller-functie en geef die waarde door aan de cast-functie en cast
‫naar een spelercontroller.
‫En dan kun je het resultaat opslaan in onze player controller ref pointer, die van het type A player controller
‫pointer is.
‫Pauzeer de video en voer de cast uit.
‫Oké.
‫Dus we hebben hier bijna al het werk gedaan dat we alleen nog hoeven te casten.
‫Dus wat we gaan doen is de cast-functie aanroepen, die zowel punthaken als haakjes heeft.
‫En wat tussen haakjes staat, is de waarde die we willen gebruiken.
‫Get controller retourneert nu een aanwijzer van Type A-controller.
‫Ik ga dat hier tussen haakjes zetten.
‫En het type waarnaar we casten is een spelercontroller.
‫Dus nogmaals, we nemen de waarde die wordt geretourneerd door get comptroller.
‫Dit retourneert een controle-aanwijzer of een adres.
‫Vervolgens gebruiken we cast om het naar een A-spelercontroller te casten.
‫We weten dat het object dat wordt geretourneerd door de gate-controller een A-speler-controller-object is dat is opgeslagen in
‫een A-controller-aanwijzer.
‫Dus nadat we dit hebben gecast, wordt een aanwijzer van het type A-spelercontroller geretourneerd.
‫Dus we slaan dat op in spelercontroller ref.
‫Nu we toegang hebben tot de controller in de vorm van een A-speler-controlleraanwijzer, hebben we toegang tot de functie die we
‫nodig hebben om het resultaat van de traceerhit onder de cursor te krijgen.
‫Dus samenvattend hebben we get controller gebruikt om toegang te krijgen tot de controller.
‫We gebruiken ook de cast-functie om te casten van de type A-controlleraanwijzer naar de type
‫A-spelercontrolleraanwijzer.
‫Nu hebben we toegang tot de functie die we nodig hebben, namelijk het krijgen van hitresultaten onder de cursor die
‫bestaat in de A-spelercontrollerklasse.
‫Dus we zullen deze functie gaan gebruiken in de volgende video.
‫Ik zie je snel.