Cum puteți salva și încărca progresul jucătorilor în unitate

În acest tutorial, veți învăța cum să implementați un sistem simplu de creare și gestionare a jocurilor de siguranță pentru jocurile dvs. Unity. Vom construi cadrul pentru a Final Fantasy-cum ar fi meniul principal care permite jucătorilor să creeze fișiere noi, să salveze unic și să încarce cele existente. Principiile demonstrate vă vor permite să le extindeți la ceea ce are nevoie jocul dvs.. 

Până la sfârșitul tutorialului, veți fi învățat cum să:

• salvați și încărcați datele jocului în Unity3D utilizând serializarea
• utilizați variabilele statice pentru a persista datele între diferitele scene

Notă: Această metodă de salvare și încărcare a datelor de joc funcționează pe toate platformele cu excepția aplicației Web Player. Pentru informații despre salvarea datelor despre jocuri în Playerul Web, consultați documentele oficiale de pe Unity Web Player și comunicarea browser-ului.

Să luăm serial

Primul lucru pe care îl vom face este să creați un cod care să ne permită să serializăm datele jocului nostru - adică să îl convertim într-un format care poate fi salvat și restaurat mai târziu. Pentru aceasta, să creăm un script C # și să îl sunăm SaveLoad. Acest script se va ocupa de toate funcțiile de salvare și de încărcare. 

Vom referi acest script la alte scripturi, deci facem o clasă statică adăugând cuvântul static între public și clasă. Să eliminăm de asemenea : MonoBehavior parte, pentru că nu trebuie să o atașăm la a GameObject. Și din moment ce nu mai moștenește MonoBehaviour, să ștergem start și Actualizați funcții. 

Codul rezultat ar trebui să arate astfel:

utilizând UnityEngine; utilizând System.Collections; clasa publică statică SaveLoad 

Acum, vom dori să adăugăm noi funcționalități acestui scenariu, așa că imediat după ce se spune utilizând System.Collections;, adăugați următoarele:

folosind System.Collections.Generic; utilizând System.Runtime.Serialization.Formatters.Binary; utilizând System.IO;

Prima linie ne permite să folosim liste dinamice în C #, dar acest lucru nu este necesar pentru serializare. A doua linie este ceea ce ne permite să folosim capabilitățile de serializare ale sistemului de operare în cadrul scriptului. În a treia linie, IO standuri pentru Intrare ieșire, și este ceea ce ne permite să scriem și să citim de pe computerul sau dispozitivul mobil. Cu alte cuvinte, această linie ne permite să creăm fișiere unice și apoi să citim mai târziu din acele fișiere.

Suntem gata să serializăm câteva date!

Efectuarea de clase serializabile

Acum că scriptul nostru are capacitatea de a se serializa, vom fi nevoiți să înființeze câteva clase pentru a fi serializate. Dacă vă gândiți la un RPG de bază, cum ar fi Final Fantasy, oferă jucătorilor capacitatea de a crea și încărca diferite jocuri salvate. Deci, creați un nou script C # numit Jocși dați-i câteva variabile pentru a ține trei obiecte: a cavaler, A derbedeu, și a vrăjitor. Modificați codul acestui script pentru a arăta astfel:

utilizând UnityEngine; utilizând System.Collections; [System.Serializable] joc de clasă publică public static joc curent; Cavalerul caracterului public; public Caracterul necinstiți; public wizard pentru caractere; joc public () knight = caracter nou (); rogue = caracter nou (); wizard = caracter nou (); 

[System.Serializable] line spune Unity că acest script poate fi serializate-cu alte cuvinte, putem salva toate variabilele din acest script. Rece! Conform documentelor oficiale, Unitatea poate serializa următoarele tipuri:

• Toate tipurile de date de bază (cum ar fi int, şir, pluti, și bool).
• Unele tipuri încorporate (inclusiv Vector2, Vector3, Vector4, quaternion, Matrix4x4, Culoare, Dreptunghi, și LayerMask).
• Toate clasele care mostenesc de la UnityEngine.Object (inclusiv GameObject, component, MonoBehavior, Texture2D, și AnimationClip).
• enums.
• Arrays și liste de tip serializabil.

Prima variabilă, actual, este o trimitere statică la a Joc instanță. Când creăm sau încărcăm un joc, vom seta această variabilă statică la acel exemplu de joc, astfel încât să putem face referire la "jocul curent" de oriunde din proiect. Folosind variabilele și funcțiile statice, nu trebuie să folosim a gameObject„s GetComponent () funcţie. La indemana! 

Observați că se referă la ceva numit a Caracter? Nu avem încă acest lucru, deci să creăm un nou script pentru a găzdui această clasă și apela la ea Caracter:

utilizând UnityEngine; utilizând System.Collections; [System.Serializable] clasa publica Caracter numele de sir public; caracterul public () this.name = ""; 

S-ar putea să te întrebi de ce avem nevoie de o clasă cu totul nouă, dacă stocăm doar o variabilă de șir. Într-adevăr, am putea înlocui Caracter în Joc script de folosit şir in schimb. Dar vreau să vă arăt cât de adânc poate merge această gaură de iepure: puteți salva și încărca clase care se referă la alte clase și așa mai departe, atâta timp cât fiecare clasă este serializabilă. 

Acum că clasele noastre sunt stabilite pentru a fi salvate și încărcate, hai să ne întoarcem la noi SaveLoad script și adăugați posibilitatea de a salva jocuri.

Salvarea stării unui joc

Un meniu "Încărcare joc" prezintă de obicei o listă de jocuri salvate, așa că să creăm un Listă de tip Joc și spune-i savedGames. Fa-o a Listă statică, astfel încât în ​​proiectul nostru să existe o singură listă de jocuri salvate. Codul ar trebui să arate astfel:

utilizând UnityEngine; utilizând System.Collections; folosind System.Collections.Generic; utilizând System.Runtime.Serialization.Formatters.Binary; utilizând System.IO; clasa publică statică SaveLoad public static List savedGames = Listă nouă(); 

Apoi, să creați o nouă funcție statică pentru a salva un joc:

 public static void Salvați () savedGames.Add (Game.current); BinaryFormatter bf = nou BinaryFormatter (); Fișier FileStream = File.Create (Application.persistentDataPath + "/savedGames.gd"); bf.Serialize (fișier, SaveLoad.savedGames); file.Close ();  

Linia 2 adaugă jocul nostru actual la lista noastră de jocuri salvate. Lista asta este ceea ce vom serializa. Pentru a face acest lucru, trebuie mai întâi să creați un nou BinaryFormatter, care se va ocupa de munca de serializare. Aceasta este ceea ce face linia 3.

În linia 4, creăm un FileStream, care este, în esență, o cale către un nou dosar pe care îl putem transmite și despre date, cum ar fi peștele înotat în aval într-un râu. Folosim File.Create () pentru a crea un fișier nou în locația în care trecem ca parametru. În mod convenabil, Unity are o locație încorporată pentru a stoca fișierele noastre de jocuri (care se actualizează automat în funcție de platforma pe care este construită jocul dvs.) pe care o putem face referire utilizând Application.persistentDataPath. 

Din moment ce creăm un fișier nou, cu toate acestea, nu putem spune doar unde este fișierul, ci trebuie să închidem această cale cu numele fișierului propriu-zis. Există două părți ale acestui fișier:

1. numele fișierului
2. tipul fișierului

Vom folosi savedGames pentru numele fișierului și vom folosi un tip de date personalizat gd (pentru "date de joc") pentru tipul de fișier. Rezultatul nostru este un fișier de joc numit savedGames.gd la locația stabilită de Application.persistentDataPath. (În viitor, puteți salva alte tipuri de lucruri la acest tip de date, de exemplu, puteți salva setările de opțiuni ale utilizatorilor ca options.gd.)

Notă: Puteți să faceți tipul fișierului orice doriți. De exemplu, seria Elder Scrolls folosește .MSE ca tip de fișier. Ați putea spune așa de ușor savedGames.baconAndGravy.

În linia 5, sunăm serializare funcționalitatea sistemului BinaryFormatter pentru a ne salva savedGames listați în noul nostru fișier. Apoi, avem aproape fișierul pe care l-am creat, în Linia 6. 

Badda bing, boala badda. Jocurile noastre sunt salvate.

Încărcarea stării unui joc

În Salvați , am serializat lista noastră de jocuri salvate într-o anumită locație. Dimpotrivă, codul pentru încărcarea jocurilor ar trebui să arate astfel:

 public static void Încărcare () if (File.Exists (Application.persistentDataPath + "/savedGames.gd")) BinaryFormatter bf = BinaryFormatter (); Fișierul FileStream = File.Open (Application.persistentDataPath + "/savedGames.gd", FileMode.Open); SaveLoad.savedGames = (Listă) Bf.Deserialize (fișier); file.Close (); 

În linia 2, verificăm dacă există un fișier de joc salvat. (Dacă nu, nu va mai fi nimic de încărcat, evident.) În linia 3, creăm a BinaryFormatter la fel cum am făcut și în Salvați funcţie. În linia 4, creăm un FileStream-dar de data aceasta, peștii noștri înotă în amonte de dosar. Astfel, folosim Fişier.Deschis, și punctul de unde ne savedGames.gd există folosind același Application.persistentDataPath şir. 

Linia 5 este puțin densă, deci să o despachetăm: 

• bf.Deserialize (fișier) apelul găsește fișierul în locația specificată mai sus și îl deserializează. 
• Nu putem scuipa doar binar la Unitate și așteptăm ca aceasta să funcționeze, totuși, așa că noi converti (sau distribuim) fișierul nostru deserializat la tipul de date pe care îl dorim să fie, care în acest caz este a Listă de tipul Joc. 
• Apoi am stabilit lista respectivă ca listă a jocurilor salvate. 

În cele din urmă, în linia 6, închidem acel dosar în același mod în care am făcut Salvați funcţie. 

Notă: Tipul de date la care aruncați datele deserializate se poate schimba în funcție de ce doriți să fie. De exemplu, Player.lives = (int) bf.Deserializați (fișier);.

Concluzie

Al nostru SaveLoad script-ul este acum complet, și ar trebui să arate astfel:

utilizând UnityEngine; utilizând System.Collections; folosind System.Collections.Generic; utilizând System.Runtime.Serialization.Formatters.Binary; utilizând System.IO; clasa publică statică SaveLoad public static List savedGames = Listă nouă(); // este statică, astfel încât să putem apela de la orice loc void static public Save () SaveLoad.savedGames.Add (Game.current); BinaryFormatter bf = nou BinaryFormatter (); //Application.persistentDataPath este un șir, deci dacă doriți să îl puteți pune în debug.log dacă doriți să aflați unde se află jocurile de salvare FileStream file = File.Create (Application.persistentDataPath + "/savedGames.gd"); // puteți să-i numiți orice doriți bf.Serialize (fișier, SaveLoad.savedGames); file.Close ();  void public static Încărcare () if (File.Exists (Application.persistentDataPath + "/savedGames.gd")) BinaryFormatter bf = BinaryFormatter (); Fișierul FileStream = File.Open (Application.persistentDataPath + "/savedGames.gd", FileMode.Open); SaveLoad.savedGames = (Listă) Bf.Deserialize (fișier); file.Close ();  

Acestea sunt elementele de bază ale salvării și încărcării în Unitate. În fișierul de proiect atașat, veți găsi câteva alte scripturi care arată modul în care gestionez apelarea acestor funcții și modul în care afișez datele utilizând GUI Unity.

Dacă aveți nevoie de un start-cap de dezvoltare a jocului dvs., încercați șabloanele Unity3D disponibile pe Envato Market.