Share
În acest tutorial vom introduce scoruri și un gameplay mai complex, cu o varietate de pickups diferite pentru a colecta, unele împiedicând jucătorul și unele care oferă viteze crește.
Vom introduce, de asemenea, un cronometru de numărare în întregime cu un HUD care va afișa atât scorul cât și timpul rămas, precum și adăugarea caracteristicii preferate a tuturor - particule!
Mini jocul nostru va avea mai multe tipuri de pickup-uri pe care utilizatorul le va putea colecta. Tipul 1 va crește pur și simplu scorul, tipul 2 va adăuga sau scade un scor aleatoriu, iar tipul 3 va grăbi sau încetini jucătorul. Pentru a-l face mai interesant, pickup-urile se vor schimba în mod aleatoriu în timp ce jucătorul joacă.
Primul pas este să creați un script nou care va defini ce tip de preluare este fiecare instanță.
Deschideți proiectul de la ultima dată sau descărcați sursa de sus; apoi în fereastra Project faceți clic dreapta pe folderul Scripts și selectați Create -> JavaScript; redenumiți-o Pickup.
Vom adăuga acum acest script nou ca o componentă a prefabricatului nostru de preluare, deci selectați "pickup-prefab" din dosarul Prefabs și trageți scriptul de preluare în fereastra Inspector (sau pe "pickup-prefab" în sine).
Fiecare instanță a pickup-ului care a apărut acum va conține acest script nou, care va determina tipul de pickup-ul și alte proprietăți. Să definim acum aceste tipuri.
Atunci când pickup-ul se produce, vom decide la întâmplare ce tip este, deci adăugați următorul cod în scriptul Pickup:
// variabilă pentru a ține tipul public var type: int; funcția Awake () // a seta un tip aleatoriu pentru a începe SwapType (); funcția SwapType () // generează un număr aleator între 1 și 10 var random: float = Random.Range (1,10); // setați tipul dacă (aleatoriu <= 5) // 50% for type 1 type = 1; else if (random <= 8) // 30% for type 2 type = 2; else // 20% for type 3 type = 3;
Blocul de cod de mai sus definește o variabilă "tip" care, la inițierea scenariului, este setat la întâmplare la o valoare de 1 (pickup de puncte standard), 2 (pick-up point gamble) sau 3 (speedup) pentru a defini tipul ridica.
Se generează numărul aleatoriu folosind Random.Range (...) și apoi se utilizează o serie de declarații if pentru a crește probabilitatea ca acesta să fie un pickup de punct standard (type = 1) și, prin urmare, face ca vitezele de pornire să fie mai rare.
Odată instanțiată, pickup-ul va rămâne în prezent același tip pe durata duratei sale de viață. Să facem ceva mai interesant făcându-l să schimbe tipul după un număr aleator de secunde.
Adăugați următoarele variabile și funcția Start () la script:
// min și max ori pentru schimbarea tipului public var minTypeChange: int = 10; public var maxTypeSchimba: int = 30; funcția Start () în timp (adevărat) // așteptați pentru x secunde randament WaitForSeconds (Random.Range (minTypeChange, maxTypeChange)); // a seta un tip aleatoare SwapType ();
Acest lucru incepe, in esenta, o buclă în timp ce va rula pentru totdeauna, deoarece condiția testată este întotdeauna adevărată. Prima parte a instrucțiunii folosește o declarație de randament WaitForSeconds (...) pentru a crea o întârziere pentru un număr aleator de secunde, între valorile min și max specificate, înainte de a schimba tipul de preluare apelând funcția SwapType pe care am definit-o mai devreme.
Deci, jocul ar trebui să funcționeze în prezent așa cum ne așteptăm - dar jucătorul nu are nicio idee despre tipul de pickup pe care îl colectează! Deci, haideți să ne lumineze puțin pickup-ul pentru a distinge între diferitele tipuri. Vom folosi funcția preferată a tuturor ...
Pentru ca jucătorul să poată spune diferența dintre pickup-uri, vom adăuga sisteme de particule colorate în centrul pickup-urilor.
Glisați o instanță a prefabricatului de preluare în scenă și focalizați-vă asupra acestuia utilizând fie tasta F, fie dând dublu clic pe ea în cadrul Ierarhiei. Adăugați un sistem de particule utilizând meniul de sus: GameObject -> Creare altul -> Sistem de particule. Faceți-i un copil al prefabricatului de preluare prin glisarea lui pe prefabricatul de preluare din cadrul Ierarhiei; dați clic pe Continuați când dialogul de mai jos vă avertizează despre pierderea conexiunii prefabricate.
Utilizați Inspectorul pentru a poziționa Sistemul de particule la (0, 0, 0) astfel încât acesta să fie în centrul modelului de preluare așa cum este ilustrat mai jos.
Notă: dacă aveți sistemul de particule sau unul dintre părinții săi selectați atunci sistemul de particule va emite particule în fereastra Scene; în caz contrar, va înceta să emită particulele până când va fi reales.
Deci, acum ar trebui să aveți primul sistem de particule poziționat în centrul pickup-ului.
Sistemele de particule din Unitate sunt alcătuite din trei componente: un emițător, un animator și un Renderer. Numele lor sunt destul de auto-explicative și fiecare prezintă o mulțime de variabile publice pentru a vă personaliza, permițând realizarea tuturor tipurilor de efecte vizuale minunate.
Puteți citi mai multe despre fiecare dintre paginile lor de referință pentru componente care sunt legate mai sus. De asemenea, puteți găsi paginile de Referință ale Scripturilor aici: Emitter, Animator și Renderer.
În prezent, sistemul nostru de particule este destul de plictisitor, nu? Selectați sistemul de particule și în cadrul Inspectorului reglați componenta Emițător pentru a se potrivi cu valorile de mai jos:
Tot ceea ce am făcut este să modificăm energia pe care o au particulele, afectând cât timp ei trăiesc și reducând elipsoidul de unde sunt emise, astfel încât acum ar trebui să observați că particulele sunt acum toate emise mai mult împreună centrul pickup-ului.
Acum potriviți componenta Animator a particulelor cu valorile indicate mai jos:
Modificările pe care le-am făcut aici sunt adăugarea unei forțe aleatoare la particulele de pe fiecare axă, pentru a le face să pară mai naturale și o dimensiune să crească cu 1, astfel încât acestea să crească în timp, după cum se arată mai jos.
Acesta este sistemul nostru de particule complet; vom regla culorile folosind scriptul de preluare.
În cele din urmă, pentru a actualiza prefabricatul de preluare, cu obiectul pickup-prefab din ierarhia selectată, faceți clic pe butonul Aplicare din partea superioară a inspectorului. Apoi, puteți șterge pickup-ul din ierarhie.
Acum, ajustați scriptul de preluare pentru a modifica culoarea particulelor în funcție de tipul de pickup.
După cum probabil ați observat în cadrul sistemului de particule Animator Component, o particulă poate anima prin cinci culori diferite, fiecare dintre ele având o valoare de culoare și alfa (transparență).
Dacă inspectați pagina de referință Script pentru Particle Animator și aruncați o privire mai atentă la proprietatea colorAnimation veți observa că este o array de obiecte de culoare.
Să introducem acum o variabilă pentru a stoca sistemul de particule al pickup-ului, astfel încât să putem accesa culorile acestuia și să introducem trei noi Arrays (datatyped to Culoare) în scriptul nostru de preluare. Mergeți mai departe și adăugați următorul cod în script:
// particulele particulelor de particule ale jocului de particule: GameObject; // culori pentru fiecare tip de pickup public var type1: Color []; public var tip2: Culoare []; public var tip3: Culoare [];
Salvați scriptul și reselectați prefabricatul de preluare în fereastra Project. Extindeți prefabricatul de preluare pentru a-i vizualiza copiii și trageți sistemul de particule care este un copil pe variabila de particule noi pentru Pickup Components.
De asemenea, ar trebui să observați acum cele trei tablouri noi în cadrul inspectorului; setați fiecare dintre dimensiunile lor la 5 ca mai jos, deoarece aceasta este cât de multe culori particulele trebuie să animați prin.
Culorile sunt în prezent negre, ceea ce nu este atât de interesant, deci selectați primul element din Type1, iar în paleta de culori rezultată selectați o culoare luminată (am folosit verde mai jos) și setați alfa (A) la 50.
Repetați acest lucru pentru restul culorilor de tip 1, mărind valoarea alfa la valoarea completă și apoi din nou, astfel încât particulele să se estompeze și să iasă - valoarea alfa pentru fiecare culoare este reprezentată de bara albă de-a lungul părții inferioare a culorii, după cum se arată mai sus . De asemenea, am ales să folosesc un verde ușor mai închis la lumină atunci când particula se estompează - puteți, desigur, să le colorați oricum doriți.
Repetați acest proces folosind culori diferite pentru Type2 și Type3 așa cum am spus mai jos.
Deci, culorile noastre au fost create. Ultimul lucru pe care trebuie să-l faceți este să le atribuiți ColorAnimation proprietatea sistemului Animator al particulelor.
Merită remarcat, așa cum se menționează în referința ColorAnimation Script, că atunci când modificați culorile prin cod, trebuie să apucați, să modificați și să re-alocați întreaga matrice, și nu culorile individuale. Putem, din fericire, să suprascriem actualul set de culoriAnimație cu propriile noastre, ceea ce este frumos și ușor.
Introduceți următoarea variabilă și suprascrieți funcția curentă Awake () cu cea de mai jos, care preia și stochează componentele ParticleAnimator pentru a le utiliza mai târziu.
// componenta animator de particule privat var particleAnimator: ParticleAnimator; funcția Awake () // recupera componentul animator de particule din particule particuleAnimator = particles.GetComponent (ParticleAnimator); // setați un tip aleatoriu pentru a începe SwapType ();
În cele din urmă, suprascrieți funcția SwapType () curentă cu următorul text:
funcția SwapType () // generează un număr aleator între 1 și 10 var random: float = Random.Range (1,10); // setați tipul dacă (aleatoriu <= 5) // 50% for type 1 type = 1; particleAnimator.colorAnimation = type1; else if (random <= 8) // 30% for type 2 type = 2; particleAnimator.colorAnimation = type2; else // // 20% for type 3 type = 3; particleAnimator.colorAnimation = type3;
Aceasta introduce o linie suplimentară pentru fiecare condiție a dacă , atribuind matricea relevantă proprietății colorAnimation a variabilei particulateAnimator. Treaba făcuta.
Dacă joci acum jocul, fiecare dintre ele va avea particule colorate în interiorul lor și ar trebui să existe mai mult cu culoarea folosită pentru Type1 decât Type2 sau Type3. Cu toate acestea, ele arata putin plictisitoare, deoarece sunt doar statice la fata locului; să adăugăm rapid o rotație aleatorie puțin pentru ei.
Acesta este un plus simplu mort, dar va face pickups noastre arata un pic mai interesant.
Adăugați următoarele variabile și Actualizați() funcție de scriptul de preluare:
// viteze de rotație min și max public var minRotationSpeed: float = 0.5; var var maxRotationSpeed: float = 2.0; // calculat viteza de rotație priv var rotationSpeed: float; funcția Update () // rotirea obiectului de joc în fiecare cadru transform.Rotate (rotationSpeed, rotationSpeed, 0); // rotiți particulele în fiecare cadru (astfel încât să se rotească la viteza dublă a întregului obiect) particles.transform.Rotate (rotațieSpeed, rotationSpeed, 0);
Apoi, suprascrieți Treaza() funcția cu următoarea, care calculează viteza de rotație aleatorie atunci când scriptul inițializează:
funcția Awake () // calcula rata de rotație aleatorie rotationSpeed = Random.Range (minRotationSpeed, maxRotationSpeed); // extrage animatorul de particule Componentă din particule particuleAnimator = particles.GetComponent (ParticleAnimator); // setați un tip aleatoriu pentru a începe SwapType ();
Dacă rulați din nou jocul, pickup-urile ar trebui să se rotească toate la viteze aleatorii! Este timpul să începeți să notați!
Înainte de a construi interfața noastră, trebuie să decidem asupra rezoluției jocului nostru și să ne asigurăm că fereastra de joc este de această rezoluție, astfel încât să putem poziționa cu exactitate elementele de interfață.
Folosesc dimensiunile standard de export WebPlayer (600x450) pe care le poți schimba folosind meniul de sus, Edit -> Project Settings -> Player. De asemenea, puteți decide ce versiune a șablonului WebPlayer doriți să o utilizați.
După ce v-ați hotărât cu privire la rezoluția jocului dvs., trebuie să setați fereastra de joc să aibă aceeași dimensiune, puteți face acest lucru utilizând meniul din colțul din stânga sus al ferestrei de joc afișat mai jos
Acum putem poziționa cu exactitate elementele de interfață în fereastra de joc, este important să ne amintim să poziționăm elemente de interfață în timp ce observăm fereastra jocului, NU fereastra de scenă.
Permiteți acum să începeți să realizați interfața noastră ...
Înainte de a începe scriptul pentru scoruri, vom construi interfața pentru a păstra scorul introducând GUITextures (GUI = Graphical User Interface), care va forma porțiunea statică a interfeței.
Descărcați acest pachet care conține fontul și textura necesară pentru interfața noastră. Fontul folosit este numit IrisUPC și este disponibil aici. Faceți dublu clic pe pachet pentru a extrage conținutul și faceți clic pe Import pentru a importa toate materialele atunci când vi se solicită fereastra de dialog Import:
Veți avea acum două foldere noi în fereastra de proiect: Fonturi și GUI.
Să începem acum să creăm GUI-ul jocului nostru. Mai întâi, adăugați un nou Empty GameObject (folosind meniul de sus), redenumiți-l la "GUI" și poziționați-l la (0, 0, 0). Acesta va fi containerul pentru interfața grafică, astfel încât ierarhia noastră este organizată cu ușurință.
Extindeți folderul GUI în fereastra proiectului și selectați "game-gui" și, folosind meniul de sus, adăugați un GUITexture: GameObject -> Create Other -> GUITexture. Ar trebui să aveți acum ceva similar celui de mai jos:
Deci, în acest moment acest lucru nu este prea mare, deoarece vrem să aliniem acest grafic cu partea de sus a ecranului.
Mai întâi, să modificăm inserția pixelului în cadrul inspectorului astfel încât punctul său de pivotare să nu mai fie în centru și apoi să îl repoziționăm de-a lungul vârfului ecranului. Selectați jocul-gui și potriviți componentele sale Transform și GUITexture cu cele prezentate mai jos:
Ceea ce am făcut aici este modificat prin adăugarea valorii pixelului GUITexture Y la -64 (care este înălțimea imaginii), astfel încât punctul său de pivotare este de-a lungul vârfului imaginii. Acum, când setăm valoarea Y în componenta Transformare la 1, GUITexture se aliniază perfect cu partea superioară a ecranului; altfel ar exista un decalaj de 32 px.
Tine minte: Când poziționați elementele GUI în unitate, (0,0) este colțul din stânga jos al ecranului și (1,1) este colțul din dreapta sus al ecranului.
Deci, asta este pentru gigantul nostru; timp pentru a adăuga GUIText ...
Cu grafica pentru interfața noastră în loc este acum momentul să introducă GUIText care va afișa scorul jucătorului și timpul rămas.
Extindeți folderul Fonturi, selectați UPCIL din Iris și apoi creați un GUIText GameObject utilizând meniul de sus: GameObject -> Create Other -> GUIText. Redenumiți-o txt-scor și să-l facem copil de GUI.
Ar trebui să aveți acum un text mic care să arate "Gui Text" apare în centrul ecranului folosind fontul UPCIL. Notă: Atunci când creați GUIText este mai ușor să selectați fontul înainte de a crea GUIText decât să îl setați ulterior.
În cadrul inspectorului, potriviți setările Transformare și componentele GUIText cu cele prezentate mai jos:
Poziționarea componentei de transformare de mai sus va alinia GUIText după cum se arată mai jos cu rezoluția WebPlayer de 600x450 - dacă utilizați o altă rezoluție, este posibil să trebuiască să redați valorile pentru ao alinia corect. Rețineți că, prin setarea valorii axei Z la 1, butonul GUIText se poziționează în fața elementului GUITexture.
Am setat textul la '888', deoarece acesta este cel mai larg pe care îl va fi vreodată; am schimbat și ancorarea pentru a centra textul, mai degrabă decât să îl aliniem spre stânga. În cele din urmă am mărit dimensiunea fontului la 36:
Acum urmați exact aceiași pași din nou - dar redenumiți GUIText-ul în timp txt - și setați Componentul său de transformare la setările de mai jos, astfel încât să aveți ceva similar cu imaginea:
Deci, asta e construcția interfeței complete, acum este momentul să-i strângem împreună.
Redenumiți scriptul PickupController și adăugați la script următoarele două variabile și funcția:
// textfield pentru a păstra scorul și scorul variabil privat var textfield: GUIText; privat var scor: int; funcția UpdateScoreText () // actualizare câmp text cu scorul textfield.text = score.ToString ();
Destul de explicativ aici. Două variabile, una pentru a urmări scorul și una pentru a stoca câmpul de text în care este afișat scorul UpdateScoreText () funcția stabilește textul câmpului de text la valoarea șirului variabilei de scor folosind ToString () funcţie.
Înainte de a fi chemată această funcție, trebuie să atribuiți câmpului text o valoare. Adăugați următorul cod la Treaza() funcţie:
Accentsconagua
textfield = GameObject.Find ("GUI / txt-scor"). GetComponent (GUIText);
scor = 0; UpdateScoreText (); Acesta va găsi GameObjectul "scor txt" - presupunând că l-ați plasat în Ierarhia dvs. așa cum vi sa cerut - și își recuperează componenta GUIText. Variabila scorului este apoi setată la 0 și UpdateScoreText () se numește.
În prezent, ar trebui să obțineți un 0 pe ecran când faceți clic pe Redare; cu toate acestea nu există nimic pentru a crește scorul, deci înlocuiți Colectate (...) funcția cu cea de mai jos:
funcția colectată (pickupCollected: GameObject) // returnați numele pickup-ului colectat și exprimat în indexul int var: int = parseInt (pickupCollected.name); // pickup-ul a fost distrus astfel încât indicele spawn să fie disponibil din nou spawnIndexAvailableList [index] = true; // returnați tipul de preluare var type: int = pickupCollected.GetComponent (Pickup) .type; // actualizați scorul în funcție de tipul de preluare dacă (tip == 1) scor + = 2; // pur și simplu adăugați 2 la scor altfel dacă (tip == 2) scor + = Random.Range (-2, 5); // adăugați un scor aleatoriu între -2 și 5 la scor // actualizați scorul UpdateScoreText (); // distruge pickup-ul Destroy (pickupCollected); // așteptați o sumă aleatorie de secunde între intervalul minimSpawnDelayTime și maximumSpawnDelayTime WaitForSeconds (Random.Range (minimumSpawnDelayTime, maximumSpawnDelayTime)); / / spawn un nou pickup SpawnPickup ();
Ar trebui să observați că am adăugat câteva linii în centrul funcției pentru a prelua variabila de tip de la pickup-ul colectat și apoi pentru a crește scorul fie cu o valoare statică de 2 pentru pickups de tip 1, fie cu o valoare aleatoare între -2 și 5 pentru ambele pickups de tip 2 și 3.
Câmpul de text este apoi actualizat după ajustarea punctajului. Ușor, corect?
Înainte de a face afișarea temporizatorului, puteți face ca unul dintre pickup-urile noastre să afecteze viteza jucătorului.
Deschideți scriptul PlayerController și adăugați următoarele variabile:
// componenta PickupController din "PickupSpawnPoints" gameObject private var characterMotor: CharacterMotor; // variabile de viteză public var minSpeed: int = 5; var var maxSpeed: int = 35; private var originalSpeed: int;
Acum înlocuiți curentul Treaza() funcționează cu următoarele:
funcția Awake () // returnați PickupSpawnPoints gameObject var pickupSpawnPoints: GameObject = gameObject.Find ("PickupSpawnPoints"); // și apoi retrageți componenta PickupController de mai sus PickupSpawnPoints gameObject pickupController = pickupSpawnPoints.GetComponent ("PickupController"); // recupera jucatorii CharacterMotor Component characterMotor = GetComponent (CharacterMotor); // recupera viteza inițială a jucătorilor de la characterMotor originalSpeed = characterMotor.movement.maxForwardSpeed; Ce sa schimbat? Am introdus o characterMotor care returnează componenta CharacterMotor a playerului, unde putem accesa viteza playerului. De asemenea, am introdus mai multe variabile de viteză pentru a urmări viteza inițială și pentru a seta valori minime și maxime ale vitezei.
Acest lucru este mare până acum, dar nu va face o diferență în cadrul jocului nostru, deoarece stocăm doar viteza inițială. Avem nevoie să regla viteza când un jucător se ciocnește cu unul dintre pickup-uri.
Inlocuieste OnControllerColliderHit (...) funcția de mai jos:
funcția OnControllerColliderHit (hit: ControllerColliderHit) // dacă jucătorul atinge un pickup dacă (hit.gameObject.tag == "Pickup") // apela funcția Collected (...) a componentei PickupController (script) pickup-ul pe care l-am lovit ca parametru pentru funcția pickupController.Collected (hit.gameObject); // dacă pickup-ul este setat la tipul 3, apoi ajustați viteza jucătorilor dacă (hit.gameObject.GetComponent (Pickup) .type == 3) // opri orice coroutine care rulează deja StopCoroutine ("AdjustSpeed"); // creați un coroutine nou pentru AdjustSpeed StartCoroutine ("AdjustSpeed"); Așadar, am adăugat o declarație suplimentară dacă testează dacă tipul de preluare este egal cu 3, care apoi va ajusta viteza prin Adjustspeed () funcţie. Mergeți și adăugați Adjustspeed () funcția de mai jos la script:
funcția AdjustSpeed () // returnează numărul aleator între 0 și 1 var rand: float = Random.Range (0.0, 1.0); dacă (rand <= 0.6) // 60% for speed boost characterMotor.movement.maxForwardSpeed = maxSpeed; else // 40% for slow down characterMotor.movement.maxForwardSpeed = minSpeed; // wait for 5-10 seconds before resetting the speed to the original speed yield WaitForSeconds(Random.Range(5,10)); characterMotor.movement.maxForwardSpeed = originalSpeed;
Adjustspeed () funcția generează un număr aleatoriu, care este apoi utilizat pentru a decide dacă să accelereze sau să încetinească playerul. Funcția așteaptă apoi o perioadă de timp cuprinsă între 5 și 10 secunde înainte de a re-aloca viteza inițială. Dacă jucați acum jocul, toate ar trebui să pară că funcționează corect.
Există totuși o problemă.
Dacă colectați un pickup de tip 3 și apoi colectați un alt pickup de tip 3 înainte ca viteza inițială să fi fost resetată, atunci funcția este încă în așteptare și astfel viteza inițială va fi resetată cu mult mai devreme decât se aștepta.
Abordarea pe care o folosim pentru a rezolva această problemă este folosirea StartCoroutine (...), trecând numele funcției ca parametru, astfel încât să putem utiliza mai târziu StopCoroutine (...) care va elimina declarația de randament WaitForSeconds (...) în cadrul funcției.
Înlocuiți apelul la Adjustspeed () în cadrul dacă declarație cu următorul cod:
// opri orice corutine care rulează deja StopCoroutine ("AdjustSpeed"); // creați un coroutine nou pentru AdjustSpeed StartCoroutine ("AdjustSpeed"); Acum, atunci când rulați jocul ar trebui să funcționeze conform așteptărilor dacă puteți găsi două pickup-uri de tip 3 în succesiune rapidă (dacă ați copiat cele de mai sus, acestea ar trebui să fie albastre).
Crearea unui cronometru în cadrul Unity este destul de simplă! Creați un nou script numit 'CountdownTimer' și adăugați următoarele variabile și Treaza() funcţie:
// câmpul de text pentru a actualiza timpul la câmpul text privat var: GUIText; // variabilele de timp public var allowedTime: int = 90; privat var actualTime = permisTime; funcția Awake () // returnați componenta GUIText și setați text textfield = GetComponent (GUIText); UpdateTimerText (); // începe ora TimerTick ();
Toate destul de simple până acum; am declarat câteva variabile și atunci când scriptul inițializează atribuim componenta GUIText a GameObject că scriptul este o componentă a variabilei de câmp text.
Apoi vom face două apeluri pentru funcții UpdateTimerText () și TimerTick (). Să începem prin adăugarea UpdateTimerText () funcția de mai jos pentru script-ul nostru:
funcția UpdateTimerText () // actualizarea câmpului text textfield.text = currentTime.ToString ();
Acest lucru este, de asemenea, destul de simplu, convertirea ora curentă variabilă într-un șir și apoi actualizarea câmpului de text cu șirul respectiv. Să adăugăm acum funcționalitatea cronometrului în scriptul nostru cu TimerTick () funcția de mai jos:
funcția TimerTick () // în timp ce rămân secunde în timp ce (currentTime> 0) // așteptați 1 secundă de randament WaitForSeconds (1); // reduce timpul curentTime--; UpdateTimerText (); // joc încheiat
Deci, mai este ceva mai mult în această funcție, dar este încă destul de simplu; Hai să aruncăm o privire…
Noi avem un in timp ce care continuă să circule până când numărul secundelor este egal cu 0 - adică jocul sa încheiat. În bucla folosim randament WaitForSeconds (...) pentru a opri executarea scriptului timp de o secundă. Când scriptul începe executarea din nou, ora curentă variabila este redusă cu 1 și câmpul text este actualizat prin apelare UpdateTimerText ().
Deoarece este a in timp ce buclă, acest flux este repetat până la ora curentă este egal cu 0, moment în care jocul se termină și "Game Over" este imprimat în consola.
Există un ultim lucru pe care trebuie să-l faceți pentru a face acest lucru - și asta este, desigur, adăugând scriptul CountdownTimer ca o componentă a GameObjectului "txt-time", deoarece altfel este doar un script neutilizat într-un dosar!
Acum rulați jocul. Ceasul ar trebui să bifeze de la 90 și să se oprească la 0. (Totuși, veți putea rula în continuare, dar vom remedia acest lucru în următorul tutorial.)
Sperăm că v-ați bucurat de acest tutorial de bază pentru începători cu Unity! Am acoperit GUITexturile, GUIText, creând cronometre și fiecare favorite - Particule! În următoarea și ultima parte a acestei serii, vom adăuga un ecran intro și final pentru jocul nostru. Ne vedem acolo!
