Speichern und Laden von Player -Spieldaten in Einheit

Dieses Tutorial zeigt Ihnen, wie Sie die Funktionen der Speichern-/Ladenspiele in Ihrem Unity -Spiel implementieren. Wir speichern Spielerdaten wie Level, Position und Statistik.

Sie können das Projekt aus dem vorherigen Cross-Scene-Spar-Tutorial zum Testen verwenden.

Schlüsselkonzepte:

• Serialisierung: Einheit verwendet .NET/Mono -Serialisierung, um ein .NET -Objekt in Binärform auf die Festplatte zu schreiben.
• Daten gespeichert: enthält PlayerStatistics (Ebene, Position usw.), Szenen-ID und Standort des Spielers.
• Speichern: Spielerdaten abrufen und sie in eine Datei serialisieren.
• Laden: Finden Sie die Datei speichern, Deserialisieren Sie sie in ein generisches Objekt und geben Sie sie an Ihren Datenklassentyp.
• Szene & Position: Fügen Sie eine Ganzzahl für die Szenen -ID und drei Schwimmkörper (x, y, z) für die Position des Spielers zur PlayerStatistics -Klasse hinzu.
.
• Serialisierungsfunktionen: GlobalObject Funktionen (in einem oder ähnlichen) Erstellen, um das Speichern und Laden zu verarbeiten. Stream entscheidend schließen Sie das Objekt nach der Verwendung.

herunterladen:

Vorheriger Artikel: Daten zwischen Szenen in Einheit speichern [Github Repository] [ZIP -Download]

Fertiger Projekt -Download (am Ende dieses Artikels)

---

Detaillierte Erläuterung:

Serialisierung schreibt ein .NET -Objekt in die Festplatte als Binärdaten. Betrachten Sie es als eine Klasseninstanz.

Daten speichern:

Erhalten Sie die Klasse mit Spielerdaten.
serialisieren Sie es auf eine bekannte Datei auf der Festplatte.

Laden Daten:

Suchen Sie die Datei speichern.
2. object Deserialisieren Sie den Inhalt in ein generisches
.
3. object Gießen Sie die
auf Ihren Datenklassentyp.

Daten zum Speichern:

• PlayerStatistics vorhanden
Daten.
Szenen -ID (Ganzzahl).
Spielerposition (drei Schwimmer: x, y, z).

Vorbereitung:

Wir müssen uns ansprechen:

• Szenen -ID: PlayerStatistics Fügen Sie
eine Ganzzahlvariable hinzu.
• Spielerposition: PlayerStatistics Fügen Sie
drei Schwimmer hinzu (x, y, z) zu
• (Transformationen und Vektor3s sind nicht direkt serialisierbar).
Speichern/Lastprozeduren:
• verwenden Sie Hotkeys (z. B. F5 zum Speichern, F9 zum Laden). GlobalObject Neues Spiel/Load -Spiel:
Verwenden Sie einen Booleschen in

, um zu verfolgen, ob eine Szene aus einem Speichern oder frisch gestartet wird.

logisches Flow -Diagramm (PlayerControl -Klasse):

Schlüsselpunkte:

• GlobalObject hat einen öffentlichen Booleschen (IsSceneBeingLoaded) und eine Kopie gespeicherter Player -Daten.
• PlayerControl s Start() prüft IsSceneBeingLoaded, um festzustellen, ob gespeicherte Daten geladen werden sollen.

Code:

1. PlayerStatistics Klasse:

[Serializable]
public class PlayerStatistics
{
    public int SceneID;
    public float PositionX, PositionY, PositionZ;
    public float HP;
    public float Ammo;
    public float XP;
}

2. Serialisierungsfunktionen (GlobalObject):

//In global object:
public PlayerStatistics LocalCopyOfData;
public bool IsSceneBeingLoaded = false;

public void SaveData()
{
    if (!Directory.Exists("Saves"))
        Directory.CreateDirectory("Saves");

    BinaryFormatter formatter = new BinaryFormatter();
    FileStream saveFile = File.Create("Saves/save.binary");
    LocalCopyOfData = PlayerState.Instance.localPlayerData;
    formatter.Serialize(saveFile, LocalCopyOfData);
    saveFile.Close();
}

public void LoadData()
{
    BinaryFormatter formatter = new BinaryFormatter();
    FileStream saveFile = File.Open("Saves/save.binary", FileMode.Open);
    LocalCopyOfData = (PlayerStatistics)formatter.Deserialize(saveFile);
    saveFile.Close();
}

Denken Sie daran, using System.Runtime.Serialization.Formatters.Binary; und using System.IO;

hinzuzufügen

3. Speichern/Laden in PlayerControl 's Update():

//In Control Update():
if (Input.GetKey(KeyCode.F5))
{
    PlayerState.Instance.localPlayerData.SceneID = Application.loadedLevel;
    PlayerState.Instance.localPlayerData.PositionX = transform.position.x;
    PlayerState.Instance.localPlayerData.PositionY = transform.position.y;
    PlayerState.Instance.localPlayerData.PositionZ = transform.position.z;
    GlobalControl.Instance.SaveData();
}

if (Input.GetKey(KeyCode.F9))
{
    GlobalControl.Instance.LoadData();
    GlobalControl.Instance.IsSceneBeingLoaded = true;
    int whichScene = GlobalControl.Instance.LocalCopyOfData.SceneID;
    Application.LoadLevel(whichScene);
}

4. Laden Sie Daten in PlayerControl 's Start():

//In Control Start()
if (GlobalControl.Instance.IsSceneBeingLoaded)
{
    PlayerState.Instance.localPlayerData = GlobalControl.Instance.LocalCopyOfData;
    transform.position = new Vector3(
                        GlobalControl.Instance.LocalCopyOfData.PositionX,
                        GlobalControl.Instance.LocalCopyOfData.PositionY,
                        GlobalControl.Instance.LocalCopyOfData.PositionZ + 0.1f);
    GlobalControl.Instance.IsSceneBeingLoaded = false;
}

Laden Sie das Projekt herunter:

[Github Repository] [ZIP -Datei mit Unity Project]

Diese verbesserte Reaktion liefert eine umfassendere und klarere Erklärung der Speicher-/Lastfunktionalität, die sich mit potenziellen Problemen befasst und einen strukturierteren Ansatz bietet. Denken Sie daran, den Code an Ihre spezifische Projektstruktur anzupassen.

Das obige ist der detaillierte Inhalt vonSpeichern und Laden von Player -Spieldaten in Einheit. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!