Eenheid

PlayerPrefs gebruiken om gegevens te lezen en te schrijven

Pagina bijgewerkt :
Aanmaakdatum van pagina :

Verificatieomgeving

Ramen
  • Voor Windows 11
Unity Editor
  • 2021.3.3f1
Input systeem pakket
  • 1.3.0

Vereisten voor deze tip

De volgende instellingen zijn vooraf gemaakt als uitgangspunt voor de beschrijving van deze tip.

Eerst

Als je games hebt gespeeld, hebben de meesten van jullie het ervaren. Je hebt waarschijnlijk een game gepauzeerd en je speelgegevens opgeslagen of geladen om uit te schakelen.

Bij het maken van een spel moet je meestal deze opslag- en laadfunctie maken, opties instellen, enz. Hier zullen we proberen dit te bereiken met behulp van de eenvoudigste PlayerPrefs manier om gegevens op te slaan en te laden.

UI-plaatsing

Hier zullen we proberen de invoerinhoud op te slaan of te lezen door de invoeritems en knoppen te plaatsen en op de knop te klikken. Vooralsnog heb je maar minimaal twee knoppen en één invoerveld nodig, dus voel je vrij om ze te plaatsen.

Voorbereiden op UI-verwerking

Laten we eerst de knop Opslaan implementeren. Hoe u een knopgebeurtenis kunt maken, wordt geïntroduceerd in de volgende tips, dus ik zal alleen de relevante onderdelen vermelden.

Laat de scriptnaam ButtonEvent staan als .

Het script ziet er als volgt uit:

using UnityEngine;
using UnityEngine.UI;

public class ButtonEvent : MonoBehaviour
{
  /// <summary>名前入力フィールド。</summary>
  [SerializeField] InputField InputFieldName;

  /// <summary>HP 入力フィールド。</summary>
  [SerializeField] InputField InputFieldHP;

  /// <summary>攻撃力入力フィールド。</summary>
  [SerializeField] InputField InputFieldAttack;

  /// <summary>お金入力フィールド。</summary>
  [SerializeField] InputField InputFieldMoney;

  /// <summary>
  /// 保存ボタンをクリックしたときの処理。
  /// </summary>
  public void OnClickSave()
  {
  }

  /// <summary>
  /// 読み込みボタンをクリックしたときの処理。
  /// </summary>
  public void OnClickLoad()
  {
  }
}

Aangezien het nodig is om de ingevoerde waarde te krijgen of in te stellen, bereidt u deze voor als een veld. Neem ook de methode op die wordt aangeroepen wanneer u op elke knop klikt.

Voeg uw EventSystem script toe aan en stel elk invoerveld in. Het kan elk object zijn dat u wilt bevestigen.

Stel in dat elke methode wordt aangeroepen wanneer op de knop wordt geklikt.

Sla de waarde op

Nu de methode wordt aangeroepen wanneer OnClickSave op de knop Opslaan wordt geklikt, is het proces van de knop Opslaan als volgt.

/// <summary>
/// 保存ボタンをクリックしたときの処理。
/// </summary>
public void OnClickSave()
{
  // 各値を指定したキーに保存します
  PlayerPrefs.SetString("Name", InputFieldName.text);
  PlayerPrefs.SetString("HP", InputFieldHP.text);
  PlayerPrefs.SetString("Attack", InputFieldAttack.text);
  PlayerPrefs.SetString("Money", InputFieldMoney.text);

  // 設定したデータを確定して保存します
  PlayerPrefs.Save();
}

PlayerPrefs.SetString De methode is ingesteld op een sleutel en een waarde die moet worden opgeslagen. De sleutel wordt opgegeven bij het laden van de opgeslagen gegevens. SetString Hier noemen we de methode omdat de op te slaan waarde een tekenreeks is. int float Als u een waarde van een ander type wilt SetInt opslaan, zoals en , zijn er methoden zoals en SetFloat , dus roep ze aan volgens het type.

PlayerPrefs.Save Roep ten slotte de methode aan om de opslag te bevestigen. Eigenlijk kan het worden opgeslagen, zelfs als u deze methode niet aanroept, maar het is veiliger om het te noemen.

Maar zelfs als je het spel op dit punt uitvoert, wordt alleen de waarde opgeslagen, dus je weet niet of het goed is opgeslagen. Als u de opgeslagen locatie controleert, kunt u de gegevens zien, maar ...

Krijg een opgeslagen waarde

Implementeer vervolgens het proces van het laden van de opgeslagen gegevens. De verwerking van de knop is hetzelfde als het opslagproces, dus alleen de code van het laadproces wordt hier beschreven.

/// <summary>
/// 読み込みボタンをクリックしたときの処理。
/// </summary>
public void OnClickLoad()
{
  // 指定したキーから値を読み込みます
  InputFieldName.text = PlayerPrefs.GetString("Name");
  InputFieldHP.text = PlayerPrefs.GetString("HP");
  InputFieldAttack.text = PlayerPrefs.GetString("Attack");
  InputFieldMoney.text = PlayerPrefs.GetString("Money");
}

Gebruik de methode om de opgeslagen gegevens te PlayerPrefs.GetString laden. U kunt de waarde die met die sleutel wordt opgeslagen, ophalen door de sleutel op te geven die is opgegeven in Opslaan als argument. De waarde wordt opgehaald in de retourwaarde van de methode.

Dit wordt ook opgeslagen als een string op dezelfde manier als bij het opslaan, dus GetString we noemen de methode. int float Als u opslaat met of , roept u GetIntGetFloat de methode aan.

De opgehaalde waarde wordt weergegeven in het invoerveld.

U kunt de gegevens nu opslaan en laden. Ik denk niet dat er moeilijke elementen zijn.

Probeer het te verplaatsen

Uitvoeren om in te voeren, op te slaan en te laden. De opgeslagen gegevens blijven behouden en moeten kunnen worden geladen, zelfs als u het spel afsluit en opnieuw uitvoert. Als je het volgende patroon kunt bevestigen, denk ik dat er geen probleem is.

  1. Voer een waarde in
  2. Klik op de knop Opslaan
  3. De ingevoerde waarde wijzigen
  4. Klik op de knop Importeren om te bevestigen dat deze terugkeert naar de opgeslagen waarde.
  5. Sluit het spel af
  6. Voer het spel opnieuw uit en klik op de laadknop om te zien of je de opgeslagen waarde kunt oproepen
  7. Voer een andere waarde in, sla deze op en controleer of u hetzelfde kunt lezen met de bijgewerkte waarde

Een stuk gegevens opslaan en laden

In de steekproef tot nu toe zijn slechts enkele parameters opgeslagen. Naarmate je daadwerkelijk een spel maakt, zal het aantal parameters dat moet worden opgeslagen gestaag toenemen, en als je ze één voor één leest en schrijft, zal de code enorm zijn. Daarom is de theorie bij het maken van gegevens die daadwerkelijk moeten worden opgeslagen, om de op te slaan gegevens in één te combineren en vervolgens allemaal tegelijk te schrijven.

Maak eerst een opgeslagen gegevensstructuur als een klasse. Het doel is om gegevens in één keer te kunnen lezen en schrijven, maar ook om de gegevens te classificeren om het voor code gemakkelijker te maken om toegang te krijgen tot elk stuk gegevens.

Hieronder volgen voorbeelden van opslaggameklassen: Het kan overal worden geschreven waar het kan worden verwezen vanuit andere code. Deze klassenstructuur is een voorbeeld, dus in een echt spel moet je het voor je spel maken.

/// <summary>セーブデータクラス。</summary>
public class SaveData
{
  public List<Character> Characters;
  public long Money;
}

/// <summary>１キャラクターの情報。</summary>
[Serializable]
public class Character
{
  public string Name;
  public int HP;
  public int Attack;
}

In de List standaardfunctie Unity die deze keer wordt gebruikt, als u arrays definieert of meerdere unieke klassen hebt, System.Serializable Als u een attribuut niet toevoegt, wordt het niet correct geconverteerd, dus Character ik stel het attribuut in op de Serializable klasse.

Nadat u de klasse hebt gemaakt, maakt u de gegevens die u wilt opslaan. Natuurlijk kun je gedurende het spel instanties van deze klasse hebben. Dit is afhankelijk van hoe het spel gemaakt is.

// 保存するデータ作成
var saveData = new SaveData
{
  Money = 10000,
  Characters = new List<Character>
  {
    new Character { Name= "レイシア", HP = 50, Attack = 40, },
    new Character { Name= "アイリ", HP = 56, Attack = 27, },
    new Character { Name= "ニール", HP = 72, Attack = 36, },
    new Character { Name= "トリー", HP = 61, Attack = 30, },
  },
};

Nadat u de gegevens in de instantie van de klasse hebt ingesteld JsonUtility.ToJson , converteert (serialiseert) u deze naar een JSON-tekenreeks met de methode. Aangezien de waarde van het object een enkele "tekenreeks" is die JSON wordt genoemd met een gegevensstructuur, kunnen allePlayerPrefs.SetString gegevens worden geschreven met een enkele aanroep van de methode.

// オブジェクトを JSON 文字列に変換します
var saveJson = JsonUtility.ToJson(saveData);

// データを保存します
PlayerPrefs.SetString("SaveData", saveJson);
PlayerPrefs.Save();

Omdat alle gegevens echter in één worden verzameld, is het niet mogelijk om slechts een deel ervan op te slaan of slechts een deel ervan te lezen. Daarom verdient het de voorkeur om er een eenheid van te maken die gemakkelijk samen te vatten is, zoals het combineren als één object voor één opgeslagen gegevens.

Bij het lezen van de opgeslagen gegevens kunt u de omgekeerde verwerking uitvoeren bij het opslaan. De te lezen gegevens zijn een enkele tekenreeks, maar de inhoud is JSON-geformatteerde gegevensstructuren, zodat JsonUtility.FromJson ze met methoden kunnen worden geconverteerd (gedeserialiseerd) naar klasse-instanties. Omdat we echter geen FromJson informatie in de tekenreeks hebben waarnaar we moeten converteren, moeten we het type opgeven bij het aanroepen van de methode.

// データを読み込みます
var loadJson = PlayerPrefs.GetString("SaveData");

// JSON 文字列からオブジェクトにデシリアライズします
var newData = JsonUtility.FromJson<SaveData>(loadJson);

Als u het probeert te verplaatsen, kunt u zien dat het correct is opgeslagen en kan worden geladen.

Overigens gebruiken we deze keer de Unity-standaardklassen JsonUtility , maar ze kunnen mogelijk geen klassen met complexe gegevensstructuren converteren omdat ze niet erg functioneel zijn. In dat geval is het aan te raden om andere bibliotheken te gebruiken.

Waar worden gegevens opgeslagen?

PlayerPrefs Wanneer u een klasse gebruikt om gegevens op te slaan, is de locatie waar deze worden opgeslagen afhankelijk van het platform waarop u werkt. Raadpleeg de officiële pagina hieronder voor waar het daadwerkelijk is opgeslagen.

In sommige omgevingen, zoals Windows, worden ze niet opgeslagen in een bestand, maar in systeeminstellingen zoals het register. Omdat het geen bestand is, is het niet geschikt voor het opslaan van opgeslagen gegevens in , bijvoorbeeld als de opgeslagen gegevens erg groot zijn of PlayerPrefs als u de opgeslagen gegevens wilt synchroniseren met een andere omgeving. Omgekeerd, als de op te slaan gegevens de grootte van het optieniveau hebben, of als het een op zichzelf staand spel is dat alleen wordt voltooid in de omgeving waarin het wordt uitgevoerd, denk ik dat het mogelijk is PlayerPrefs om de gegevens op te slaan in .

Bovendien kan het pad van de opgeslagen locatie worden beïnvloed door de instellingen "Bedrijfsnaam" en "Productnaam". Als je je spel wilt publiceren, moet je deze waarden ruim van tevoren bepalen en ze niet wijzigen zodra je je spel publiceert.

Informatie over gegevensversleuteling

Opgeslagen gegevens worden niet automatisch versleuteld. Als de vaardigheden van de speler worden opgeslagen zoals ze zijn, zal de gebruiker de waarden vrij herschrijven, wat van invloed is op het spel.

Moet u versleutelen, en zo ja, welk sterkteniveau is vereist en hoe gaat u om met de coderingssleutel? Dingen om te overwegen variëren van spel tot spel.

Ik zal de coderingsmethode hier niet uitleggen, maar als je het op internet opzoekt, is het een belangrijke taal en tool, dus ik denk dat er verschillende methoden zijn. Voorlopig, als u de betekenis van de opgeslagen inhoud niet begrijpt, zelfs als u het bestand opent, en als u slecht met de gegevens knoeit, kunt u de opgeslagen gegevens niet gebruiken, ik denk dat er een antifraude-effect zal zijn.

Renderstructuren gebruiken om de inhoud van een andere scène als structuren weer te geven
Schrijf gegevens naar het aanbevolen mappad van Unity dat is opgegeven door persistentDataPath