‫Hallo en welkom.
‫In deze lezing gaan we een KML-spelmodus maken, wat slechts een van de mogelijke
‫spelmodi zal zijn die we kunnen creëren dankzij een virtuele - gedode methode die in elk spel kan worden
‫aangeroepen modi die we willen.
‫Laten we erin duiken en kijken hoe we deze virtuele methode gaan implementeren.
‫Dus we willen dat ons spel kan eindigen.
‫Wat betekent het als een spel eindigt?
‫Het betekent dat we in een soort van toestand komen waarin we die ene hebben of die we hebben verloren.
‫We informeren de speler met behulp van een gebruikersinterface.
‫We geven ze de mogelijkheid om misschien opnieuw op te starten en opnieuw te spelen, iets in die richting.
‫De klassen die hierbij betrokken zijn, zijn meestal een spelmodus.
‫De spelmodus is verantwoordelijk voor het bepalen van regels over het spel, zoals wie heeft gewonnen en wie heeft verloren.
‫En daarvoor moeten we weten wie er vermoord wordt.
‫Dus we gaan deze virtuele methode gebruiken, genaamd pion gedood, die zal worden aangeroepen als schietpion
‫als hij sterft.
‫Of het nu de A is of niet. L. of het is de speler die aan het sterven is.
‫En verder wil ik hier een kleine complicatie toevoegen, namelijk dat er verschillende spelmodi
‫zullen zijn die zijn afgeleid van onze hoofdschietspelmodus.
‫Ze zullen die spelmodus implementeren.
‫Dat is wat de pijl hier betekent.
‫Het is vaak een beetje contra-intuïtief hoe de pijl gaat, maar dood ze allemaal.
‫De spelmodus erft van de schietspelmodus en heft de gedode pion op om op te tellen en anders
‫te beslissen over de spelregels.
‫Daarom wil ik een virtuele pion-gedood-methode in de ouder-shooter-spelmodus zetten en deze vervolgens opnieuw
‫implementeren of negeren in de kill all-spelmodus, wat de spelmodus wordt die we voor
‫onszelf implementeren.
‫En je kunt ervoor kiezen om verschillende spelmodi te doen, waarbij je misschien een bepaald aantal vijanden in
‫het level wilt doden in plaats van ze allemaal of iets in die richting.
‫Misschien een vlag veroveren, iets anders.
‫Maar wat er in feite gaat gebeuren, is dat de shooter -- die de game-modus gaat vinden die de
‫game-modus van het type shooter heeft en het zal noemen ---- gedood.
‫En dan, afhankelijk van de implementatie die er is, gaat het via de override
‫door naar de implementatie.
‫Een andere complicatie hier is dat onze UI-logica en herstartlogica echt iets is dat zou moeten gebeuren in de
‫gebruikersinterface van de spelercontroller, die over het algemeen de bevoegdheid van de speler is in plaats van iets globaals zoals
‫de spelmodus.
‫Dit geldt met name in games die multiplayer zijn, omdat de gamemodus niet echt op de computer van de speler
‫bestaat, maar alleen op de server.
‫Dus alle UI-dingen zouden in de spelercontroller moeten plaatsvinden.
‫Dat is een complicatie waar we ons geen zorgen over hoeven te maken
‫omdat dit geen multiplayer-game is, maar het is nog steeds goed om de klassen te gebruiken waarvoor ze in Unreal worden verwacht.
‫Dus de spelercontroller, de eigenlijke root-spelercontrollerklasse heeft een virtuele methode genaamd game is speciaal voor
‫dit doel geëindigd, zodat de gamemodus deze methode kan aanroepen en we kunnen deze in onze eigen shooter-play-controller implementeren
‫om UI te doen, een herstarten van alles dat soort dingen.
‫Maar we moeten het vanuit onze spelmodus oproepen als we hebben besloten dat het spel voorbij is.
‫Dus we noemen het virtuele spel is geëindigd op de root-speler-controller en omdat die root-speler-controller
‫eigenlijk een shooter-speler is, zal een controller uiteindelijk terugschakelen en bellen.
‫Dit spel is afgelopen.
‫Dus het lijkt een omslachtige route die we gaan bellen van onze shooter-pion via de shooter-spelmodus om ze
‫allemaal te doden in de spelmodus naar de spelercontroller naar de shooter-spelercontroller.
‫Maar dit geeft ons veel flexibiliteit in termen van, nou ja, we kunnen verschillende spelcontrollers mixen en matchen die
‫de gebruikersinterface op verschillende manieren en op verschillende niveaus laten zien.
‫We kunnen verschillende spelmodi mixen en matchen die op verschillende manieren zullen werken, en dat is de reden
‫waarom ik het op deze manier heb ontworpen.
‫Het is een beetje overkill voor ons project, maar het laat zien hoe dit kan worden uitgebreid naar
‫andere projecten met het vastleggen van de spelmodi en verschillende soorten spelercontrollers.
‫Dus laten we het gaan implementeren.
‫We gaan op zoek naar een routespelmodus.
‫Er is er al een gemaakt omdat ik ben begonnen met een C++-project.
‫We hebben een eenvoudige schietspelmodusbasis en wat ik hier wil doen, is een openbare
‫functie creëren die ongeldig zal worden en die zal worden - gedood en we zullen moeten passeren in de -
‫die werd hier vermoord.
‫Dus het wordt een -- ster genaamd -- die zo wordt vermoord.
‫En dan, in het begin, gaan we hier een virtuele methode van maken en
‫we gaan door en creëren een basisimplementatie die hier in wezen niets doet.
‫Dan gaan we een subklasse maken.
‫Dus nieuwe C++-klasse, we gaan alle klassen tonen en we gaan op zoek naar shooter simple
‫shooter game mode base als onze basisklasse en we gaan dit de kill em all game-modus noemen en ga je gang en
‫creëer die klas.
‫Als dat is gecompileerd, wil ik gewoon even overschakelen en naar ons shooter-personage gaan.
‫CP En je kunt hier zien dat we onze is dood in de take damage methode.
‫Als dit dood is, wil ik onze spelmodus bemachtigen en de -- gedood noemen.
‫Dus de manier waarop we dit doen, is dat we beginnen met bellen om de wereld te krijgen om de spelmodus te krijgen.
‫Dan is het uit de spelmodus.
‫En wat we dan willen doen, is dat deze spelmodus van het juiste type is, de
‫eenvoudige, de basismodus, de eenvoudige schietspelmodus waarmee we dit personage vervolgens kunnen uitschakelen, gebruiken met
‫verschillende spelmodi, zoals capture the flag-spelmodi.
‫Dus de manier waarop we dit kunnen doen, kunnen we de punthaken gebruiken hier in de get- of game-modus.
‫En we gaan een eenvoudige schietspelmodus doen en die moeten we bovenaan opnemen.
‫Dus voeg een eenvoudige shooter-spelmodus toe, zodat ik de naam van de hele klas niet helemaal goed kreeg.
‫I denk.
‫Het wordt dus een eenvoudige schietspelmodus.
‫Dat is wat we proberen te krijgen en we kunnen doorgaan en dat opslaan in een variabele aanwijzer, laten we het
‫de spelmodus noemen.
‫En wat we dan willen doen is op deze nieuwe regel, we willen waarschijnlijk controleren of we dit hebben en het
‫is geen nulaanwijzer.
‫De spelmodus is dus niet gelijk aan een nulwijzer.
‫En als het dan niet gelijk is aan alle punten van dat is waar we de spelmodus pijlpion gedood willen noemen
‫en de gedode pion, is dit dan zo?
‫Dus nu weet de spelmodus dat er een pion is gedood.
‫Kleine mini-uitdaging voor jou om de spelmodus Kill them all te negeren, zodat je dat kunt.
‫Log uit wanneer de -- wordt gedood en stel dat in als de standaard spelmodus op je kaart.
‫Oké.
‫Dus hopelijk heb je die kleine mini-uitdaging geprobeerd.
‫We gaan aan de slag en implementeren.
‫Dus ik ga dit doen door het openbare gedeelte van onze eenvoudige shooter-spelmodusbasis te kopiëren, en het is moeilijk om al
‫deze dingen bij te houden.
‫Dan gaan we naar onze kill-ze-all-spelmodusbasis, die ervan erft.
‫En we gaan de virtuele methode plakken en we gaan het override-sleutelwoord toevoegen om ervoor te zorgen dat
‫we deze methode correct overschrijven.
‫Dan ga ik een implementatie maken in de C ++ voor onze KML-spelmodusbasis.
‫Dit is waar we dat logbericht zouden moeten krijgen.
‫En om heel voorzichtig te zijn, weten we dat er niets in de implementatie zit.
‫Maar je weet maar nooit.
‫Dingen kunnen later veranderen en we kunnen een beetje in de bom worden.
‫Dus we willen een pion doden.
‫Super -- gedood met de -- gedood.
‫Klinkt logisch.
‫En dan willen we hier een dialoog voeren die in feite zegt dat een -- werd vermoord.
‫En we kunnen zien of dat werkt door naar Unreal te gaan en te compileren, dan naar het
‫blauwdrukken-item op de werkbalk te gaan en in de projectinstellingen te selecteren.
‫De standaard spelmodus die we willen zijn, als we de spelmodus, basisklasse selecteren, willen we dat het de basisspelmodus
‫is die ze allemaal vermoorden, ga je gang en doe dat.
‫In feite is dat niet helemaal wat we willen doen als we gaan selecteren.
‫We wilden eigenlijk dat het daar een blauwdrukkind van zou zijn en we hebben al een blauwdrukkind dat een heleboel dingen
‫heeft ingesteld.
‫Dus laten we daar een ouderschapstaak doen.
‫We gaan naar de wortels, we zullen de BP shooter-spelmodus vinden, die we hier hebben.
‫We gaan deze BP hernoemen, kill alle spelmodus en dan kunnen we dat openen, het venster dokken, de
‫volledige blauwdrukeditor openen, naar de klasinstellingen gaan en de ouder wijzigen in de KML-spelmodus, in feite
‫C++.
‫En op die manier zouden we de juiste code moeten gebruiken als we naar ons bericht gaan om
‫log uit te voeren en op play te drukken en dan een personage te doden. We hebben een probleem lijkt niet de juiste
‫instelling te hebben, dus als we teruggaan naar de standaardinstellingen van de klas en verander de standaard -- class in het BP shooter-personage, dat zou
‫correct moeten zijn.
‫Opslaan en compileren voor het geval het fout zou gaan.
‫En bekijk dan mijn blauwdrukken hier.
‫Het heeft het KML-spel geselecteerd, het C++-spel.
‫Dus we willen hier eigenlijk de blauwdruk kiezen en doorgaan en op play klikken.
‫Nu hebben we onze pion.
‫We kunnen doorgaan en deze man doden en je kunt zien dat er een pion is gedood.
‫Staat Prince in het logbericht?
‫Dat werkt dus fantastisch.
‫Nu, in het volgende gedeelte, gaan we kijken naar het tweede deel
‫hiervan, namelijk dat het spel is afgelopen, terwijl we het spel echt willen beëindigen en vanaf dat moment opnieuw willen beginnen.
‫Dus ik zie je in die lezing.