«Пошаговое руководство по созданию системы сохранения в Unity для начинающих»

markdownCopy codeПошаговое руководство по сохранению данных в Unity

В этой части статьи мы рассмотрим процесс сохранения данных в проектах на юнити. Мы изучим, как создать функционал для сохранения информации об объекте и как впоследствии использовать эти данные. Это позволит игрокам сохранять свои достижения и прогресс в игре, что существенно повышает удовольствие от игрового процесса.

Для начала создадим скрипт, который будет управлять сохранением и чтением данных. Мы назовем его SaveLoadManager. Этот скрипт будет ответственен за сериализацию и десериализацию данных, сохраняя их в файле на устройстве игрока.

Создаем скрипт SaveLoadManager и добавляем в него следующий код:

using System;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using UnityEngine;
public class SaveLoadManager : MonoBehaviour
{
public static SaveLoadManager instance;
private void Awake()
{
if (instance == null)
{
instance = this;
DontDestroyOnLoad(gameObject);
}
else
{
Destroy(gameObject);
}
}
public void SaveData(GameData data)
{
BinaryFormatter formatter = new BinaryFormatter();
string path = Application.persistentDataPath + "/savedata.dat";
FileStream stream = new FileStream(path, FileMode.Create);
formatter.Serialize(stream, data);
stream.Close();
}
public GameData LoadData()
{
string path = Application.persistentDataPath + "/savedata.dat";
if (File.Exists(path))
{
BinaryFormatter formatter = new BinaryFormatter();
FileStream stream = new FileStream(path, FileMode.Open);
GameData data = formatter.Deserialize(stream) as GameData;
stream.Close();
return data;
}
else
{
Debug.LogError("Save file not found in " + path);
return null;
}
}
}

Теперь создадим класс GameData, который будет содержать сериализуемые данные об игре. Например:

[Serializable]
public class GameData
{
public int playerLevel;
public float playerHealth;
public string[] inventoryItems;
}

Этот класс будет содержать все необходимые данные, которые мы хотим сохранить. Для примера мы добавили уровень игрока, его здоровье и список предметов в инвентаре.

Чтобы сохранить данные в игре, мы создаем экземпляр GameData и вызываем метод SaveData:

GameData data = new GameData();
data.playerLevel = 5;
data.playerHealth = 75.5f;
data.inventoryItems = new string[] { "sword", "shield", "potion" };
SaveLoadManager.instance.SaveData(data);

Для загрузки данных используем метод LoadData и восстанавливаем состояние игры:

GameData loadedData = SaveLoadManager.instance.LoadData();
if (loadedData != null)
{
int level = loadedData.playerLevel;
float health = loadedData.playerHealth;
string[] inventory = loadedData.inventoryItems;
// Используйте загруженные данные для восстановления состояния игры
}

Теперь рассмотрим, как можно управлять сохраненными данными с помощью PlayerPrefs. Это менее гибкий метод, но он может быть полезен для хранения небольших объемов данных.

Для сохранения данных используем методы PlayerPrefs.SetInt, PlayerPrefs.SetFloat, PlayerPrefs.SetString:

PlayerPrefs.SetInt("PlayerLevel", 5);
PlayerPrefs.SetFloat("PlayerHealth", 75.5f);
PlayerPrefs.SetString("InventoryItem1", "sword");
PlayerPrefs.SetString("InventoryItem2", "shield");
PlayerPrefs.SetString("InventoryItem3", "potion");

Для чтения данных используем методы PlayerPrefs.GetInt, PlayerPrefs.GetFloat, PlayerPrefs.GetString:

int level = PlayerPrefs.GetInt("PlayerLevel");
float health = PlayerPrefs.GetFloat("PlayerHealth");
string item1 = PlayerPrefs.GetString("InventoryItem1");
string item2 = PlayerPrefs.GetString("InventoryItem2");
string item3 = PlayerPrefs.GetString("InventoryItem3");

В конце рассмотрим создание кнопок для сохранения и загрузки данных:

Кнопка	Действие
Save	Вызов метода SaveData()
Load	Вызов метода LoadData()

Теперь у вас есть возможность сохранять и загружать данные в ваших играх на юнити, используя методы сериализации и PlayerPrefs. Экспериментируйте с этими подходами и создавайте более сложные системы для сохранения состояния игры!

Простой способ: PlayerPrefs

Когда вам нужно сохранить данные между игровыми сессиями, можно воспользоваться удобным методом PlayerPrefs. Этот подход позволяет быстро и эффективно сохранять различные типы данных, такие как параметры игрока, настройки и прогресс.

Чтобы начать работу, сначала создайте скрипт, в котором будет реализован процесс сохранения и загрузки данных. В этом примере мы будем использовать ключи для сохранения и загрузки значений. Например, если вы хотите сохранить позицию объекта, вы можете использовать метод PlayerPrefs.SetFloat.

Вот пример кода:

using UnityEngine;
public class SaveGame : MonoBehaviour
{
private Vector3 playerPosition;
void Update()
{
if (Input.GetKeyDown(KeyCode.S))
{
SaveData();
}
if (Input.GetKeyDown(KeyCode.L))
{
LoadData();
}
}
void SaveData()
{
PlayerPrefs.SetFloat("PlayerPositionX", playerPosition.x);
PlayerPrefs.SetFloat("PlayerPositionY", playerPosition.y);
PlayerPrefs.SetFloat("PlayerPositionZ", playerPosition.z);
PlayerPrefs.Save();
Debug.Log("Данные сохранены.");
}
void LoadData()
{
playerPosition.x = PlayerPrefs.GetFloat("PlayerPositionX");
playerPosition.y = PlayerPrefs.GetFloat("PlayerPositionY");
playerPosition.z = PlayerPrefs.GetFloat("PlayerPositionZ");
Debug.Log("Данные загружены.");
}
}

Этот скрипт сохраняет и загружает позицию игрока. Вы можете использовать аналогичный подход для сохранения других данных, таких как игровые параметры или результаты. PlayerPrefs поддерживает сохранение данных типа int, float и string.

Вот еще один пример, где мы сохраняем строку и целое число:

PlayerPrefs.SetString("PlayerName", "Player1");
PlayerPrefs.SetInt("HighScore", 1000);

И для их загрузки:

string playerName = PlayerPrefs.GetString("PlayerName");
int highScore = PlayerPrefs.GetInt("HighScore");

В некоторых проектах может возникнуть необходимость очистить все сохраненные данные. Это можно сделать с помощью метода PlayerPrefs.DeleteAll:

PlayerPrefs.DeleteAll();

Используя PlayerPrefs, у вас есть возможность легко управлять сохранением и загрузкой данных без сложных сериализуемых объектов и дополнительных библиотек. Этот подход особенно полезен в небольших проектах и простых играх.

Если вам нужен более сложный подход, рассмотрите использование файлов или баз данных, которые позволят работать с большими объемами информации и обеспечат более гибкую структуру данных.

Метод	Описание
PlayerPrefs.SetFloat	Сохраняет значение типа float по указанному ключу.
PlayerPrefs.GetFloat	Загружает значение типа float по указанному ключу.
PlayerPrefs.SetString	Сохраняет строковое значение по указанному ключу.
PlayerPrefs.GetString	Загружает строковое значение по указанному ключу.
PlayerPrefs.SetInt	Сохраняет значение типа int по указанному ключу.
PlayerPrefs.GetInt	Загружает значение типа int по указанному ключу.
PlayerPrefs.DeleteAll	Удаляет все сохраненные данные.

Теперь вы знаете, как использовать PlayerPrefs в ваших проектах. Это простой, но эффективный способ сохранить данные между игровыми сессиями и дать игроку возможность продолжить игру с того места, где он остановился.

Преимущества и недостатки PlayerPrefs

Преимущества

• Простой в использовании: PlayerPrefs предоставляет легкий способ хранить информацию, что делает его подходящим для небольших проектов и быстрых изменений.
• Мгновенный доступ: Данные сохраняются и загружаются быстро, что позволяет игроку получать нужные значения без задержек.
• Кроссплатформенность: PlayerPrefs работает на различных платформах, включая Windows, macOS и мобильные устройства.
• Не требует сериализации: Этот метод не требует дополнительных усилий по сериализации данных, что упрощает процесс разработки.

Недостатки

• Ограниченные возможности: PlayerPrefs подходит только для хранения простых данных типа строк, чисел и булевых значений. Для более сложной информации придется использовать другие методы.
• Низкая безопасность: Хранение данных в PlayerPrefs не защищено от вмешательства, что может быть критично для игровых данных, особенно в онлайн проектах.
• Ограничение на размер данных: Некоторые платформы накладывают ограничения на размер данных, которые можно хранить с помощью PlayerPrefs, что может создать проблемы в крупных проектах.

Практическое использование

Для сохранения данных с помощью PlayerPrefs необходимо создать экземпляр класса, который будет управлять загрузкой и сохранением информации. Например, вы можете создать класс SaveLoadManager, который будет иметь методы для записи и чтения значений.

Пример кода для сохранения и загрузки значения:

public class SaveLoadManager : MonoBehaviour
{
public void SaveGame(string stringToSave)
{
PlayerPrefs.SetString("SavedString", stringToSave);
PlayerPrefs.Save();
}
public string LoadGame()
{
if (PlayerPrefs.HasKey("SavedString"))
{
return PlayerPrefs.GetString("SavedString");
}
return null;
}
}

В этом примере данные сохраняются в файле, который Unity создает автоматически, и загружаются по мере необходимости. Таким образом, вы можете легко интегрировать этот метод в свой проект и использовать его для хранения простых данных.

Использование PlayerPrefs имеет свои особенности, и важно понимать, когда этот метод будет уместен, а когда лучше выбрать другой способ хранения информации.

Пример сохранения и загрузки данных

Начнем с сохранения значений. Создадим класс SaveLoadManager, который будет отвечать за сохранение и загрузку данных. В этом классе объявим несколько переменных, например, private int saveInt, для хранения числовых значений. Мы также создадим метод SaveData, который будет сохранять нужные данные в файле.

Пример кода для сохранения данных:

using System;
using System.IO;
using UnityEngine;
public class SaveLoadManager : MonoBehaviour
{
private int saveInt;
public void SaveData()
{
saveInt = 10; // Пример значения для сохранения
string path = Application.persistentDataPath + "/savedgames.txt";
StreamWriter writer = new StreamWriter(path, false);
writer.WriteLine(saveInt.ToString());
writer.Close();
Debug.Log("Данные сохранены в файле: " + path);
}
}

В этом примере мы сохраняем значение saveInt в текстовом файле savedgames.txt. Файл сохраняется в директории Application.persistentDataPath, которая используется для хранения данных, сохраняемых между сессиями игры.

Теперь рассмотрим, как загрузить сохраненные данные. Добавим метод LoadData, который будет читать данные из файла и присваивать их соответствующим переменным.

Пример кода для загрузки данных:

public void LoadData()
{
string path = Application.persistentDataPath + "/savedgames.txt";
if (File.Exists(path))
{
StreamReader reader = new StreamReader(path);
string value = reader.ReadLine();
saveInt = int.Parse(value);
reader.Close();
Debug.Log("Данные загружены из файла: " + path);
}
else
{
Debug.Log("Файл не найден: " + path);
}
}

Теперь мы можем вызывать методы SaveData и LoadData в нужные моменты игрового процесса, например, при выходе из игры или загрузке нового уровня. Это поможет сохранить текущий прогресс игрока и вернуться к нему позже.

Таким образом, используя сериализацию данных и работу с файлами, мы можем сохранить важные игровые значения и загружать их при необходимости. Это простой, но эффективный способ работы с сохраненными данными в игровых проектах.

Сложный способ: Сериализация

Если вам нужен более продвинутый метод, который позволит сохранять сложные данные, сериализация будет отличным выбором. Этот метод используется в проектах, где требуется работать с объектами, которые имеют множество значений и типов данных. Сериализация даёт возможность напрямую сохранять и загружать сложные структуры данных, такие как классы, через преобразование их в последовательность байтов.

Чтобы начать, вам понадобится создать класс, который будет отвечать за хранение данных. Этот класс будет содержать все нужные значения и методы, необходимые для сериализации и десериализации.

• Создайте новый класс с названием, например, SaveData, который будет содержать значения, которые необходимо сохранить.
• Определите публичные поля или свойства для каждого значения, которое вы хотите сохранить, например, public int score или public Vector3 playerPosition.
• Реализуйте методы Save и Load, которые будут использовать сериализацию для сохранения и загрузки данных в файл.

Ниже приведён пример класса, который можно использовать в вашем проекте:

[System.Serializable]
public class SaveData {
public int score;
public Vector3 playerPosition;
}
public class GameManager : MonoBehaviour {
private string saveFilePath;
void Start() {
saveFilePath = Application.persistentDataPath + "/savefile.json";
}
public void Save() {
SaveData data = new SaveData();
data.score = 100; // Пример значения
data.playerPosition = new Vector3(0, 0, 0); // Пример позиции
string json = JsonUtility.ToJson(data);
System.IO.File.WriteAllText(saveFilePath, json);
}
public void Load() {
if (System.IO.File.Exists(saveFilePath)) {
string json = System.IO.File.ReadAllText(saveFilePath);
SaveData data = JsonUtility.FromJson(json);
// Используйте загруженные данные
int score = data.score;
Vector3 position = data.playerPosition;
}
}
}

Этот подход позволяет сохранять сложные данные в удобном формате, который легко загружать и использовать в игровом процессе. Правда, он может показаться сложнее, чем простой способ с использованием PlayerPrefs, но в крупных проектах это часто оказывается более гибким и мощным решением.

Если вам нужно больше контроля над процессом сохранения, сериализация даёт возможность создавать собственные методы для обработки данных. Например, вы можете переопределить метод Update, чтобы автоматически сохранять состояние игры в определённые моменты, или создавать резервные копии данных в случае сбоя.

Таким образом, сериализация в Юнити – это мощный инструмент, который открывает перед игроком больше возможностей для работы с данными. Вы можете сохранить и восстановить любой тип значений, включая сложные объекты и структуры, что значит, что ваши игровые данные всегда будут под надёжной защитой.

Подготовка к сериализации

Первым шагом на этом пути является создание класса SaveLoadManager, который будет управлять процессами сериализации и десериализации. Этот класс должен включать методы SaveData и LoadData, которые будут отвечать за запись и чтение данных.

SaveLoadManager должен содержать public поля, такие как Vector3 для сохранения положения объектов и string для сохранения текста. Например, если вам нужно сохранить положение лампы (lamp), вы можете использовать переменную Vector3, чтобы сохранить её координаты.

Для правильного сохранения данных, необходимо создать экземпляр класса SaveState, который будет включать в себя все сериализуемые объекты. Этот экземпляр должен содержать все значения, которые вы хотите сохранить, такие как int для уровней, string для имен, и другие нужные данные.

Важным аспектом является использование ключей для хранения данных. Например, можно создать ключ saveInt, который будет сохранять уровень качества (quality) или торговые навыки (trading) игрока. Таким образом, при чтении данных, мы сможем точно восстановить нужные значения.

Код-класс SaveLoadManager должен также включать методы для обновления (Update) сохраненных данных. Например, при изменении позиции объекта, нам нужно будет вызвать метод, который сохранит новые координаты в SaveState. Это позволит сохранить точное состояние игрового мира на момент выхода.

Кроме того, в SaveLoadManager необходимо реализовать функции для сохранения данных на различных платформах, таких как Windows. Это значит, что ваша система должна учитывать особенности каждой платформы, чтобы данные сохранялись корректно.

Важный момент: сериализуемые объекты должны быть помечены атрибутом [Serializable]. Это значит, что класс будет включать только те поля, которые должны быть сохранены. Например, в классе PlayerData можно сериализовать информацию о здоровье и положении игрока.

Видео:

Как ПРАВИЛЬНО сделать передвижение в Unity? Нормали поверхностей + Чистый код на C#