Computers zijn heel slim omdat ze bijna alles kunnen en veel sneller kunnen rekenen dan mensen. Maar ze zijn ook dom omdat ze alleen precies kunnen doen wat de programmeur (jij dus) heeft gezegd dat ze moeten doen. Hierom moet je altijd heel goed opletten dat de computers alles kan begrijpen wat je ertegen zegt. Als je een hoofdletter, een haakje of een punt vergeet snapt de computer het al niet meer. Daarnaast spreekt de computer geen mensentaal zoals Nederlands of Engels, maar een programmeertaal. Instructies voor de computer in een programmeertaal worden code genoemd. De programmeertaal die we in deze lessen gaan gebruiken is C# (C-Sharp). In deze tweede les leer je de basis van C# en gaan we code schrijven om de Player die we vorige les gemaakt hebben te laten lopen.
Scripts
Als je in Unity het Player object willen laten bewegen met bijvoorbeeld de pijltjestoetsen moet je dit aan de computer laten weten. Dit doe je door een script toe te voegen aan het object. Een script maak je door met je rechtermuisknop in de Assets folder te klikken, dan naar ‘create’ te gaan en dan uit de lijst ‘C# script’ te selecteren. Je moet dan de naam van je script invoeren. Noem je eerste script “Player”, omdat je dit voor de Player gaat gebruiken. Je kan dit dan naar de inspector van je object slepen om het toe te voegen:
Je kan een script ook via de ‘Add Component’ knop toevoegen, zoals je vorige les geleerd hebt.
Je Eerste Regel Code
Als je nu in de Assets folder dubbelklikt op het script zal het programma Visual Studio openen waarin we de code kunnen gaan schrijven. Je zal dan dit zien:
Dit is het script van de Player klasse (class). Hierin zullen we alle code zetten die met de Player te maken heeft. De class begint met public class Player : MonoBehaviour { en eindigt met het laatste haakje }. Het is belangrijk dat alles wat je in dit script schrijft binnen deze twee haakjes komt, anders denkt de computer dat het er niet bij hoort. Tussen de haakjes van de class zien we twee blokjes met tekst. Dit zijn methodes, ook wel functies genoemd. Een methode is een groep instructies voor de computer die bij elkaar hoort en achter elkaar uitgevoerd moet worden.
De instructies die je tussen de { } haakjes van de Start methode zet worden uitgevoerd zodra de game begint. De instructies tussen de { } haakjes van de Update methode worden constant uitgevoerd. Achter de namen van de methodes staan ook normale ( ) haakjes, maar daar doen we nu nog niets mee. Het is wel belangrijk om te leren dat achter de naam van een methode altijd ( ) haakjes moeten komen.
De groene tekst boven de methodes zijn commentaar voor de programmeur en worden door de computer niet gelezen. Als je zelf commentaar wil toevoegen moet je de regel beginnen met //. Het commentaar dat er nu staat kan je zonder problemen verwijderen.
Met de eerste regel code die je gaat schrijven gaan we testen of alles werkt. Tussen de { } haakjes van de Start methode schrijf je print(“Hallo”);
De print() methode is een methode die een stukje tekst als bericht naar de Console van de computer stuurt. Het stukje tekst moet tussen aanhalingstekens ” “ staan, want daardoor de computer dat je tekst bedoelt. Achter elke regel code komt een puntkomma ;. Op je toetsenbord staat die naast de L. Dit mag je nooit vergeten, want anders weet de computer niet wanneer de regel code geëindigd is. Als je het wel vergeet zal Visual Studio je onderin het scherm, in de Error List een waarschuwing geven.
Om te testen of alles werkt sla je nu dit script op met de toetsenbord-combinatie ‘ctrl + s’ of door bovenin het scherm naar ‘File -> Save Assets\Player.cs’ te gaan. Als je nu terug gaat naar Unity en op de startknop drukt zal als het goed is onder in het scherm en in de Console ‘Hallo’ komen te staan:
De Player Laten Lopen
De code die je moet schrijven om de Player te laten lopen is iets ingewikkelder dan de eerste regel die je hebt geschreven. Voordat je ook maar een letter schrijft moet je precies bedenken wat je wil dat de computer gaat doen. In dit geval willen we dat het player object naar links beweegt als we op de linker pijltjestoets drukken en naar rechts als we op de rechter pijltjestoets drukken. Verder willen we dat we de snelheid waarmee de Player beweegt kunnen instellen vanuit Unity. Tenslotte willen we ook dat als we geen toets meer indrukken de Player stil blijft staan en niet door blijft lopen.
Nu moeten we dat allemaal aan de computer doorgeven op een manier die de computer kan begrijpen. In de vorige les heb je geleerd dat je het Rigidbody2D component van het Player object gebruikt om de Player te laten bewegen. Dat ga je nu ook gebruiken, maar voordat je dat component in de code kunnen gebruiken moet je het een naam geven waarvan de computer weet dat als je die naam gebruikt je dat component bedoelt. Zo’n naam noemen we een variabele. Variabelen gebruiken we niet alleen om componenten een naam te geven, maar bijvoorbeeld ook voor cijfers die de computer moet onthouden, zoals de loopsnelheid van de Player.
De code om variabelen aan te maken zetten we bovenin de class, op de regel na het eerste { haakje en boven de Start() methode. Om een variabele aan te maken schrijf je eerst het type variabele dat je wil maken. Voor de Rigidbody2D is dat Rigidbody2D, voor een cijfer is dat int of float. Een int (integer) is een heel getal zonder cijfers achter de komma. Een float (floating-point number) is een getal dat wel cijfers achter de komma kan hebben. Achter dit type zet je de naam die je de variabele wil geven. De naam die je de variabele geeft is hoofdletter-gevoelig en er mogen geen spaties inzitten. Als je meerdere variabelen van hetzelfde type aan wil maken kan je hier meerdere namen neerzetten met een komma ertussen. Achter de hele regel code komt zoals altijd een puntkomma (;). Als je wil dat je de variabele vanuit Unity of vanuit andere classes wil aanpassen moet je voor het type van de variabele public zetten.
Geef de Rigidbody2D variabele de naam Body en maak voor de loopsnelheid een float variabele aan met de naam LoopSnelheid:
Als je nu terug gaat naar Unity kan je in de Inspector van de Player bij het Player script component zien dat er twee regels verschenen zijn. Bij Loop Snelheid kan je nu een cijfer daarvoor invoeren. Bij Body moet je daar instellen dat we het Rigidbody2D component van de Player zelf bedoelen. Dit doe je door dat component naar het vakje achter Body te slepen:
Nu we de variabelen hebben aangemaakt kunnen we ze gebruiken in de code. Omdat de computer constant moet checken of er een toets ingedrukt is ga je deze code schrijven in de Update() methode. Alle code die hierin staat wordt immers constant uitgevoerd. Om bij te houden of de Player naar links moet bewegen, naar rechts moet bewegen of stil moet blijven staan maken we in de Update() methode een tijdelijke variabele aan. Een variabele die je aanmaakt in een methode werkt alleen binnen die methode en als die methode alle code heeft uitgevoerd wordt hij weer verwijderd. Je kan variabelen ook meteen een waarde geven door een = achter de naam te zetten en dan de waarde. De variabele moet van het type float zijn omdat we een getal willen bijhouden. De waarde die het op het begin moet hebben is 0, omdat je wil dat de Player niet beweegt als we geen toets ingedrukt hebben. We noemen deze variabele xsnelheid omdat het de horizontale snelheid bij moet houden. De hele regel code is dus float xsnelheid = 0;.
Nu moeten we de waarde van xsnelheid aanpassen als er op een toets gedrukt is. Dit doen we door een if te gebruiken. Het woordje if betekent ‘als’. Je schrijft if met normale ( ) haakjes erachter en tussen die haakjes zet je iets dat waar moet zijn als de computer de volgende regel code uit mag voeren. Als wat tussen de haakjes staat niet waar is dan zal de computer de volgende regel overslaan. Om te testen of een toets is ingedrukt gebruiken we een methode uit de Input klasse genaamd GetKey( ). Om deze methode te gebruiken typ je Input.GetKey( ). Tussen de haakjes van de GetKey() methode moet je dan aangeven welke toets je wil laten testen. Dit doe je met een KeyCode. Om de verschillende KeyCodes te gebruiken typ je KeyCode, dan een punt en dan kan je uit de lijst die verschijnt de toets kiezen die je wil gebruiken. Als je de eerste letter van de toets typt wordt de lijst kleiner en kan je de toets die je zoekt makkelijker vinden. De KeyCode die je nu gaat gebruiken is KeyCode.RightArrow. Dit is de KeyCode voor de rechterpijltjestoets. De hele if regel wordt dus if (Input.GetKey(KeyCode.RightArrow)). Omdat deze regel geen instructie voor de computer is hoeft hier geen puntkomma achter.
Op de volgende regel stel je de xsnelheid in zodat de Player naar links zal gaan. Dit doe je door de xsnelheid gelijk te maken aan de LoopSnelheid variabele die je boven in de class hebt aangemaakt en die je in Unity kan instellen. Dit doe je weer met een =. De regel code wordt dus xsnelheid = LoopSnelheid;. Nu kan je deze twee regels (de if regel en de regel die we net gemaakt hebben) kopiëren en onder deze regels plakken. Dit doe je omdat je ongeveer dezelfde code nodig hebt om de Player de andere kant op te laten gaan. De KeyCode moet je aanpassen naar Keycode.LeftArrow en voor LoopSnelheid zet je een min (–):
Door een – voor de LoopSnelheid te zetten stel je de xsnelheid in op het tegenovergestelde van de LoopSnelheid, dus de andere kant op met dezelfde snelheid. Nu moet je nog een regel code schrijven om het object echt te laten bewegen met de snelheid die je nu als xsnelheid hebt ingesteld. Hiervoor gebruik je de Body variabele die je eerder aangemaakt hebt. De snelheid waarmee de Body beweegt kan je aanpassen door de waarde van Body.velocity te veranderen. Body.velocity is van het type Vector2. Een Vector2 bestaat uit 2 floats: een x en een y waarde. Als je de x waarde aanpast zoals je nu gaat doen zal het object waar de Body een component van is naar links of naar rechts bewegen. Als je de y waarde aanpast zal het naar boven of beneden bewegen. Om de velocity aan te passen stel je hem gelijk (met = ) aan een nieuwe Vector2. Je schrijft hiervoor new Vector2( , ). De waarde die je voor de komma zet is de x waarde en na de komma de y waarde. De x waarde van deze Vector2 moet de xsnelheid variabele worden. De y waarde moet hetzelfde blijven want die wil je nu niet aanpassen. Als y waarde stel je dus de waarde in die de velocity nu al heeft en daarvoor gebruik je Body.velocity.y. De hele regel code wordt dus Body.velocity = new Vector2(xsnelheid, body.velocity.y);. De hele Update methode moet er nu zo uitzien:
Je kan het script nu opslaan en uittesten! Als je alles goed hebt gedaan kan je de Player nu naar links en rechts laten bewegen met de pijltjestoetsen! Als je nog geen extra blokjes toegevoegd hebt aan je Scene kan je dat nu doen zodat de Player een grond heeft om op te lopen. Vergeet niet hiervoor Prefabs te gebruiken! Als je merkt dat je player omvalt kan je in het Rigidbody2D component van de Player op het pijltje voor Constraints klikken en dan het vakje tussen Freeze Rotation en Z aan te vinken.
De Player Laten Springen
Nu de Player naar links en rechts kan bewegen moeten we er ook voor zorgen dat de Player naar boven kan bewegen. Hiervoor gaan we code toevoegen die de Player laat springen. De code die we gebruiken voor het springen lijkt erg op die voor het lopen, maar er zijn een paar kleine aanpassingen.
Je gaat de code weer schrijven in de Update() methode, omdat de computer constant moet testen of de springtoets is ingedrukt. Zorg ervoor dat onder in de Update() methode dus wat ruimte is om de nieuwe code te schrijven door een paar keer op Enter te drukken. Je begint weer met if en tussen de haakjes beginnen we weer met Input. In plaats van de GetKey() methode gebruik je nu de GetKeyDown() methode. Deze is alleen waar op het moment dat de toets is ingedrukt en niet als je hem ingedrukt houdt, zoals bij de GetKey() methode. Tussen de ( ) haakjes zet je weer de KeyCode die je voor het springen wil gebruiken. Laten we voor het springen de spatiebalk gebruiken. De KeyCode voor de spatiebalk is KeyCode.Space. De hele if regel is dus if (Input.GetKeyDown(KeyCode.Space)).
Omdat we straks wat extra dingen willen toevoegen aan het springen gaan we hiervoor een nieuwe methode maken. Maak hiervoor wat ruimte onder het afsluitende } haakje van de Update() methode, maar wel binnen de class, dus boven het onderste } haakje. Zoals je bij de Start() en Update() methodes hebt gezien begint een methode met het woordje void. Dit is niet zo bij alle methodes, maar voor nu hoef je dat nog niet te weten. Begin de regel dus met void en typ daarna de naam die we de nieuwe methode geven: Spring. Achter de naam van een methode komen altijd ( ) haakjes. Daarna plaats je nog { } haakjes op de volgende regels om aan te geven welke regels code bij deze methode horen:
Binnen deze { } haakjes ga je de code schrijven die uitgevoerd moet worden als de Spring() methode aangeroepen wordt. Hiervoor ga je weer de Body.velocity aanpassen met een new Vector2 ( , ). Dit keer moet je de x waarde hetzelfde laten, dus zet je daar Body.velocity.x. Voor de y waarde moet je een nieuwe float variabele aanmaken boven in de klasse. Schrijf daarom boven in de class achter LoopSnelheid, maar voor de puntkomma , SpringHoogte. Die hele regel moet dus public float LoopSnelheid, SpringHoogte; zijn. Deze variabele kan je straks weer in Unity aanpassen. Voor nu kan je hem gebruiken als de y waarde in de Vector2. Eindig die regel weer met een ;. Die hele regel wordt dus Body.velocity = new Vector2(Body.velocity.x, SpringHoogte);. Je kan de Spring() methode nu gebruiken. Zet op de regel na de if regel die je net in de Update() methode hebt gemaakt Spring();. Dit vertelt de computer dat alle regels code die in de Spring() methode staan uitgevoerd moeten worden zodra de spatiebalk ingedrukt wordt.
Je kan het script weer opslaan en in Unity testen. Vergeet niet in de Inspector van de Player de Spring Hoogte aan te passen! Je kan experimenteren met verschillende Springhoogtes totdat je een vind die goed vind. De Player kan nu springen, maar omdat de computer elke keer dat er op de spatiebalk gedrukt wordt de Player zal laten springen kan je blijven springen, zelfs als de Player al in de lucht is. Om dit te voorkomen moet je bijhouden of de Player wel of niet op de grond staat. Alleen als dat waar is moet de Player kunnen springen.
De Player 1 Keer Laten Springen
Om dit bij te houden maak je een nieuwe variabele, dit keer van het type bool. Een bool (boolean) is een variabele die waar (true) of niet waar (false) kan zijn. Noem deze bool variabele OpDeGrond. In de Spring() methode voeg je nu de regel OpDeGrond = false; toe, want zodra je springt sta je niet meer op de grond. Het maakt niet uit waar in de Spring methode je dit neerzet, zolang het tussen de { } haakjes is die bij de methode horen. Je moet OpDeGrond ook weer true maken als de Player weer op de grond terechtkomt, want anders kan de Player maar 1 keer springen.
Hiervoor gebruiken we een nieuwe methode: OnCollisionEnter2D(). Alle code die je in deze methode zet wordt uitgevoerd zodra het object waar het script aan vastgemaakt is ergens tegenaan botst. Plaats deze methode weer onderaan in de class, maar wel weer binnen de { } haakjes. Voor de naam van deze methode komt weer void en na de naam komen weer ( ) en { } haakjes. Het zou kunnen dat Visual Studio de haakjes vanzelf plaatst en ook wat extra dingen toevoegt. Deze extra dingen kan je weghalen of negeren. De code die je in de methode zet is simpel: OpDeGrond = true;. Dit zorgt er dus voor dat zodra het Player object ergens tegen aan botst, OpDeGrond op true wordt gezet.
Nu ga je ervoor zorgen dat de Player niet meer kan springen als OpDeGrond false is. Dit doe je door bovenaan in de Spring() methode een if regel aan te maken met OpDeGrond tussen de ( ) haakjes achter de if. Voor OpDeGrond maar binnen de haakjes achter de if zet je een uitroepteken !. Dit betekent ‘niet’. De volgende regel wordt dus alleen uitgevoerd als OpDeGrond niet waar is! De volgende regel code is maar één woord: return;. Deze regel code zorgt ervoor dat de methode afgebroken wordt en alles wat onder return; staat niet wordt uitgevoerd.
Als je het script nu weer opslaat en test in Unity zal je zien dat de Player nog maar een keer kan springen totdat je weer een blokje aanraakt!
De Volledige Player Klasse
Hieronder staat de volledige code die we deze les voor de Player klasse gemaakt hebben:
De Volgende Les
Je hebt nu de basis voor een spel met een Player karakter dat kan lopen en springen. In de volgende lessen gaan we meer scripts maken en steeds meer dingen toevoegen aan het spel. Als je de basis van C# die je deze les hebt geleerd goed begrijpt zullen de volgende lessen makkelijker zijn dan deze. Als je het nog niet helemaal snapt zal je in de volgende lessen kunnen oefenen met het maken van variabelen, methodes en klassen. Je kan ook altijd hieronder een vraag stellen. De volgende les gaat zich richten op het maken van nieuwe levels en het toevoegen van doelen om de levels te kunnen halen!