‫Hé, welkom terug.
‫In deze video houden we ons bezig met winnende en verliezende voorwaarden.
‫Dit is een van de laatste dingen die we gaan doen in dit spelproject.
‫Laten we nu eens kijken naar ons sectieplan.
‫Nu hebben we de eerste vijf items van ons sectieplan al afgevinkt, en de laatste twee zijn de speciale
‫effecten en de voorwaarden voor winnen en verliezen.
‫En ik zou deze laatste twee willen omwisselen en de voorwaarden voor winnen en verliezen willen afhandelen,
‫alleen omdat dit de laatste is van onze gameplay-programmeerlogica en de speciale effecten cosmetisch zijn en meer als finishing touch, zodat
‫we die helemaal aan het einde kunnen afhandelen.
‫In deze video gaan we een game over-functie maken, zodat we weten wanneer de game
‫is gewonnen of verloren.
‫En om het spel te winnen, moeten we het aantal torens in de wereld tellen, want als we
‫eenmaal alle torens hebben vernietigd, weten we dat we het spel hebben gewonnen.
‫En als de tank zelf wordt vernietigd, kunnen we dat als de verliessituatie beschouwen.
‫Dus ik ben weer terug in de spelmodus en het eerste wat ik zou willen doen, is een nieuwe blauwdruk-implementeerbare
‫gebeurtenis maken.
‫We hebben deze functie voor het starten van een spel, die we kunnen aanroepen vanuit C++, maar we implementeren de logica ervan in de
‫spelmodus.
‫Blauwdruk Dankzij Blueprint Implementable Event wil ik er nog een maken omdat ik het spel heb
‫verloren.
‫Dus ik ga een ongeldige functie maken met de naam Game Over.
‫En voor deze zou ik een booleaanse invoerparameter willen nemen met de naam B one game.
‫En natuurlijk wordt dit een in blauwdruk implementeerbare gebeurtenis, want het enige dat ik met deze
‫functie zou willen doen, is laten zien dat we het spel hebben verloren of gewonnen en dat we dat kunnen doen met blauwdrukken.
‫We hebben dus een game over-functie.
‫Nu moeten we weten wanneer we deze functie moeten aanroepen.
‫Allereerst weten we dat we deze functie kunnen aanroepen als we het spel hebben verloren, en dat
‫zal zijn als de tank dood is.
‫Dus laten we ingaan op onze acteur stierf-functie hier in tune tanks spelmodus CP. En we zien dat als de dode acteur
‫de tank is, we de vernietiging van de tank afhandelen en we stellen de ingeschakelde staat in
‫op false.
‫Een ander ding dat we hier kunnen doen, is het spel beëindigen door simpelweg game over te noemen en deze boolean is een spel
‫dat we hiervoor onwaar kunnen doorgeven.
‫Dus dat zorgt ervoor dat je het spel verliest, althans vanaf de C++-kant.
‫Nu moeten we weten wanneer we de wedstrijd moeten winnen.
‫Nu stierf hier een acteur.
‫Als de dode acteur naar een toren kan worden geworpen, weten we dat we zojuist een toren hebben vernietigd.
‫Dit zou de perfecte plek zijn om een torentelling bij te werken of een variabele van het integer-type die
‫bijhoudt hoeveel torens er momenteel in de wereld zijn.
‫Nutsvoorzieningen.
‫Om dat te doen, hebben we een variabele nodig om het aantal torens bij te houden, zodat we
‫een privévariabele hier in het H-bestand kunnen toevoegen.
‫En dat zou ik hier graag willen doen.
‫Dus ik ga een INT 32 maken en ik ga dit doeltorens noemen.
‫Nu kunnen we dit meteen initialiseren naar een waarde van nul, maar we moeten dit bijwerken naarmate
‫het aantal torens afneemt.
‫En we moeten dit ook instellen op het aantal torens dat er in de wereld is.
‫Nu kunnen we dit hard coderen tot vier, maar wat gebeurt er als we meer torens aan onze niveaus gaan toevoegen?
‫Nou, dan wordt het een beetje ingewikkelder.
‫Dus wat ik in plaats daarvan zou willen doen, is kijken hoeveel torens er in de wereld zijn.
‫Nu zou ik hiervoor een functie kunnen maken die 32 retourneert en deze functie kan uitzoeken hoeveel torens er in
‫de wereld zijn en het getal retourneren.
‫Dus ik ga deze functie aanroepen, een doeltorentelling krijgen.
‫Dus laten we doorgaan en deze functie een body geven in het CP-bestand.
‫Ik ga helemaal naar beneden en maak de functietekst en ik mag niet vergeten de
‫klassenaam voor de functienaam te plaatsen.
‫Dit keert een einde 32 terug en we moeten beslissen hoe we gaan uitzoeken hoeveel torens er
‫zijn.
‫Nu is er een functie die bestaat in gameplay-statistieken genaamd Get All Actors of class.
‫Hier is de documentatie.
‫Er staat Zoek alle acteurs in de wereld van de opgegeven klasse.
‫We moeten dus een bepaalde klasse specificeren.
‫Deze functie heeft nu drie ingangen.
‫De eerste is een wereldcontextobject.
‫Die is makkelijk.
‫Wij weten daar mee om te gaan.
‫Maar vervolgens hebben we een PT-subklasse van een acteur en dit wordt de acteursklasse genoemd.
‫Nu hebben we gezien dat functies die een PT-subklasse van vereisen, een u-klasse als invoer kunnen accepteren en de
‫derde parameter is een T-array.
‫Het vereist een t-array van actor-pointers en dit wordt doorgegeven als een referentie en het is geen
‫const-referentie die lijkt te suggereren dat deze functie deze invoerparameter genaamd act zou kunnen veranderen.
‫Hier is nog een hint dat dit het geval is, namelijk dat het acteurs worden genoemd.
‫Het is een out-parameter, wat betekent dat we het doorgeven en nadat de functie is aangeroepen, heeft het waarden die er
‫door de functie in zijn gezet.
‫We kunnen het dus zien als een soort uitvoer voor de functie.
‫Nu staat hier beneden voor parameters, actorklasse is de klasse van actor die moet worden gevonden, moet worden opgegeven, anders
‫is de resultaatarray leeg.
‫We willen alle torens vinden en uit acteurs is een uitvoerarray van acteurs van de opgegeven klasse.
‫Dus als we deze functie eenmaal hebben aangeroepen en een array hebben doorgegeven, wanneer de
‫functie is voltooid, bevat die array verwijzingen naar alle actoren in de wereld van de opgegeven klasse.
‫We weten dus dat deze functie een wereldcontextobject vereist.
‫Als we dit nu vanuit de spelmodus gaan noemen, kunnen we dit hierna doorgeven.
‫We hebben de PT-subklasse nodig voor het specificeren van de A-acteur en we weten dat dit een nieuwe klassenaanwijzer kan zijn.
‫Nu moeten we de te zoeken klasse specificeren.
‫Als we een acteur specificeren, krijgen we een grote reeks met verwijzingen naar elke acteur in de wereld.
‫Maar we hebben niet alle acteurs nodig.
‫We hebben alleen de torens nodig, zodat we een statische torenklasse kunnen gebruiken die ons een nieuwe klasse oplevert die
‫de klasse A Tower C++ vertegenwoordigt.
‫Nu is de derde parameter een T-array van een actor-pointers.
‫Dus als we een lokale variabele van het type T-array maken die de actor-aanwijzer tussen de punthaken specificeert, dan
‫kunnen we je gameplay-statistieken noemen.
‫Zorg ervoor dat alle acteurs van klasse slagen in die drie ingangen, en het resultaat van deze actie zal
‫zijn dat onze torenreeks verwijzingen moet bevatten naar alle torens in onze wereld.
‫Nu is de tray een mooie containerklasse die een aantal elementen kan bevatten, zolang ze allemaal hetzelfde
‫type hebben.
‫En deze klasse heeft nogal wat functies die we kunnen gebruiken bij het opbergen van items in een lade.
‫Nu ga ik helemaal naar beneden scrollen en je deze functie laten zien, Num Short four number genaamd, en
‫er staat Retourneert het aantal elementen in de array.
‫Dus we kunnen deze functie gebruiken om het aantal elementen in onze array te krijgen zodra we alle torens ter wereld
‫hebben.
‫Dus als we Tower's num noemen, dan kunnen we dit gebruiken als de retourwaarde voor onze functie.
‫En zoals we zagen, hebben we onze retourwaarde voor deze functie, die we get target tower count noemen, ingesteld als een
‫n 32, we kunnen het aantal elementen in de array van onze toren retourneren.
‫Dus ik zou je willen uitdagen om deze functie voor het tellen van de doeltoren te implementeren.
‫Maak dus een lokale t-array van type A-acteur.
‫Je kunt het torens noemen of wat je maar wilt.
‫Gebruik nu de you game, play statics-functie, haal alle acteurs van de klas en zorg ervoor dat je de
‫juiste invoerparameters doorgeeft.
‫Nu, nadat je deze functie hebt aangeroepen, zal je lade verwijzingen bevatten naar alle torens
‫in onze wereld, dus je kunt eenvoudig het aantal torens retourneren met de num-functie die tot de
‫ladeklasse behoort.
‫Dus ga je gang en pauzeer de video en implementeer.
‫Krijg nu het aantal doeltorens.
‫Oké.
‫Dus hier is het aantal doelwittorens.
‫Nu, het eerste dat ik ga doen, is een lokale t-array maken die een actor-pointer specificeert als het type
‫element dat deze array moet opslaan.
‫En ik ga dit torens noemen, nu moet ik je gameplay-statistieken noemen, dus ik moet ervoor zorgen dat
‫die header wordt opgenomen.
‫Nu zie ik dat het is omdat we het in sommige van onze andere functies gebruiken, maar het is goed om die controle uit
‫te voeren.
‫Vervolgens kan ik je gameplay-statistieken gebruiken en ik ga alle acteurs van de klas bellen.
‫Nu is de eerste invoer een wereldcontextobject dat ik hierin ga doorgeven en de volgende is de subklasse van
‫het vertegenwoordigen van de actorklasse.
‫En ik zei dat we een statische torenklasse kunnen gebruiken die een U-klasse teruggeeft die de torenklasse
‫vertegenwoordigt.
‫Nogmaals, het is een goed idee om ervoor te zorgen dat we torens opnemen, wat we ook zijn.
‫Nu, de derde en laatste parameter wordt de lade en we kunnen in torens passeren.
‫Dus als deze functie eenmaal is aangeroepen, bevatten torens nu verwijzingen naar alle torens in de
‫wereld.
‫Als er objecten van een klasse bestaan die afgeleid zijn van torens, zouden we die ook krijgen.
‫Dus omdat we een torenarray hebben, kunnen we eenvoudig het aantal elementen in die array retourneren.
‫Dus ik ga een return-statement gebruiken en towers dot num gebruiken en nu hebben we een get-target tower-telling.
‫Dit is dus geweldig.
‫We kunnen dit gebruiken om onze torentelling te initialiseren, die we doeltorens noemden en we kunnen dat doen wanneer we het
‫spel starten.
‫Dus ik ga dat hier plaatsen en de start van het spel afhandelen.
‫Ik zou zelfs willen dat dit het eerste is wat we doen.
‫Dus ik ga doeltorens nemen en deze gelijk stellen aan de retourwaarde van het aantal doeltorens ophalen.
‫Nu moeten doeltorens worden geïnitialiseerd op het aantal torens in onze wereld.
‫Dus dit is geweldig, maar we moeten deze telling bijwerken elke keer dat een toren sterft, wat betekent
‫dat we naar onze acteur stierf-functie moeten gaan.
‫En hier, als we een dode acteur naar een vernietigde toren hebben gegooid, moeten we, nadat
‫we de vernietiging hebben afgehandeld, onze variabele doeltorens bijwerken, zodat we doeltorens kunnen zeggen en we de decrement-operator kunnen gebruiken.
‫We kunnen ofwel de post-decrement-operator of de hachelijke operator gebruiken.
‫Beide zullen resulteren in dezelfde actie die doeltorens neemt en er één van aftrekt.
‫Nu, zodra we er één van de doeltorens hebben afgetrokken, moeten we nu controleren of de doeltorens
‫nul hebben bereikt.
‫Dus ik ga hier een if-check plaatsen om te zien of Target-torens nul hebben bereikt.
‫Nu, zodra dat het geval is, weten we dat het spel voorbij zou moeten zijn, zodat we de
‫game over-functie kunnen noemen in een echt 4b1-spel, aangezien we alle torens hebben vernietigd en we dit als een overwinning kunnen beschouwen.
‫Laten we nu doorgaan en onze code compileren.
‫Nu, hier in de editor, wat ik zou willen doen voordat we deze video afronden, is naar onze
‫spelmodusblauwdruk gaan.
‫Dus hier is een pieptoon.
‫Bedankt spelmodus en we hebben dit evenement startspel.
‫En wat we doen, is onze widget voor het starten van een game maken en deze toevoegen aan de viewport, zodat we de
‫afteltimer voor de start van de game kunnen zien.
‫Dus we weten dat het startspel wordt genoemd, maar we moeten ook ons spel implementeren via een implementeerbare
‫blauwdrukgebeurtenis.
‫Dus ik ga met de rechtermuisknop klikken en game over typen en hier is ons evenement, game over en bekijk dit.
‫Merk op dat we dit ene spel hebben en het is een boolean.
‫Dus als we deze functie vanuit C++ aanroepen, geven we een booleaanse waarde door voor B one game.
‫Het blauwdrukgebeurtenisknooppunt verwijdert die kleine letter B en plaatst een spatie tussen één en spel als een soort hoffelijkheid
‫voor ons.
‫Nu gaan we wat widgets maken zodat we kunnen zien wanneer we de game hebben gewonnen of verloren, maar dat zullen
‫we in een toekomstige video doen.
‫Voor nu wil ik alleen maar bevestigen dat dit correct wordt aangeroepen en aangeroepen, zodat ik dat kan doen met
‫een printstring-knooppunt en we de waarde kunnen afdrukken op basis van deze boolean.
‫Als ik op deze boolean klik en deze rechtstreeks naar de invoer in string sleep, zullen we zien dat er een convert boolean
‫to string is.
‫Dit is een ander handig conversieknooppunt dat een boolean voor ons in een string omzet, en de functionaliteit is zodanig
‫dat het wordt geconverteerd naar het woord waar of onwaar op basis van de waarheidswaarde van de
‫boolean.
‫Dus waarom testen we dit niet uit?
‫Ik ga compileren en op play drukken.
‫Oké, nu ben ik klaar om te proberen het spel te winnen.
‫Hopelijk verlies ik niet voordat ik dat kan.
‫En ik heb het spel verloren en je kunt linksboven in het scherm valse afdrukken zien.
‫Dus we weten nu dat het verliezen van het spel ertoe leidt dat het event game over wordt afgeroepen en false wordt doorgegeven, we moeten
‫ervoor zorgen dat true wordt doorgegeven wanneer we het spel winnen.
‫Dus laten we proberen alle torentjes te doden.
‫Dus ik moet echt mijn best doen om geen hit te krijgen.
‫Oh, ik ben al geraakt.
‫Dit is behoorlijk uitdagend.
‫En daar gaan we.
‫En waar wordt linksboven in het scherm afgedrukt.
‫Het wordt maar een paar seconden weergegeven, dus je hebt het misschien gemist.
‫Oke geweldig.
‫Dus nu hebben we winnende en verliezende voorwaarden.
‫De volgende stap is om dit daadwerkelijk in de vorm van een widget op het scherm weer te geven, zodat we niet afhankelijk zijn
‫van de print string node.
‫Kortom, we hebben nu voorwaarden voor winnen en verliezen, en er zijn slechts een paar dingen die we moeten doen
‫om dit op te poetsen, zoals het maken van widgets die de speler laten weten dat ze het spel hebben gewonnen of verloren.
‫We telden ook het aantal torens met behulp van een dienblad en de functie voor gameplay-statistieken.
‫Haal alle acteurs van klasse.
‫Goed werk.
‫Dit spel komt er echt aan.
‫In de volgende video zullen we die widgets maken en dan zijn we klaar om speciale effecten toe te voegen en
‫onze game op te poetsen.
‫Ik zie je in de volgende video.