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

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

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

В этом процессе мы будем использовать различные методы и свойства, такие как PlayerPrefs, private, public, override, чтобы манипулировать сохраненными данными. Мы также разберем, как хранить переменные типа string, int, и как сериализовать более сложные структуры. Особое внимание будет уделено правильному чтению и записи данных в файл, чтобы избежать ошибок и потери информации.

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

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

Создание класса для сохранения данных

Для начала нам нужно создать класс, который будет отвечать за сохранение и загрузку данных. Пусть это будет класс SaveData. В этом классе мы определим все нужные поля, которые будут сохраняться. Например, это может быть позиция игрока, его имя и уровень:

[System.Serializable]
public class SaveData
{
public Vector3 playerPosition;
public string playerName;
public int playerLevel;
}

Сохранение данных с использованием PlayerPrefs

Unity предоставляет встроенный механизм для сохранения данных — PlayerPrefs. Давайте создадим метод, который будет сохранять данные игрока:

public void SaveGame(SaveData data)
{
PlayerPrefs.SetString("PlayerPosition", JsonUtility.ToJson(data.playerPosition));
PlayerPrefs.SetString("PlayerName", data.playerName);
PlayerPrefs.SetInt("PlayerLevel", data.playerLevel);
PlayerPrefs.Save();
}

Загрузка данных

Теперь создадим метод для загрузки сохраненной информации. Он будет считывать данные из PlayerPrefs и возвращать объект SaveData:

public SaveData LoadGame()
{
SaveData data = new SaveData();
if (PlayerPrefs.HasKey("PlayerPosition"))
{
data.playerPosition = JsonUtility.FromJson<Vector3>(PlayerPrefs.GetString("PlayerPosition"));
data.playerName = PlayerPrefs.GetString("PlayerName");
data.playerLevel = PlayerPrefs.GetInt("PlayerLevel");
}
return data;
}

Удаление данных

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

public void DeleteSaveData()
{
PlayerPrefs.DeleteAll();
}

Использование созданных методов

Чтобы интегрировать сохранение и загрузку в игровой процесс, создадим отдельный скрипт SaveLoadManager и разместим там созданные методы. В момент, когда нужно сохранить данные (например, при выходе из игры), будем вызывать метод SaveGame, а при старте игры — LoadGame:

public class SaveLoadManager : MonoBehaviour
{
private SaveData currentSaveData;
void Start()
{
currentSaveData = LoadGame();
if (currentSaveData != null)
{
// Применить загруженные данные к объектам игры
// Например: player.transform.position = currentSaveData.playerPosition;
}
}
public void SaveGameData()
{
SaveData data = new SaveData();
// Заполнить данные текущими значениями
// Например: data.playerPosition = player.transform.position;
SaveGame(data);
}
}

Таблица ключевых методов

Метод	Описание
SaveGame	Сохраняет текущие данные игрока в PlayerPrefs
LoadGame	Загружает данные игрока из PlayerPrefs
DeleteSaveData	Удаляет все сохраненные данные

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

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

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

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

• Сначала создаем скрипт, который будет отвечать за управление сохраненными данными. Назовем его SaveLoadManager.
• В этом скрипте создаем методы для сохранения и чтения данных.

Пример скрипта:

public class SaveLoadManager : MonoBehaviour
{
private void SaveInt(string key, int value)
{
PlayerPrefs.SetInt(key, value);
PlayerPrefs.Save();
}
private int LoadInt(string key)
{
return PlayerPrefs.GetInt(key);
}
private void SaveString(string key, string value)
{
PlayerPrefs.SetString(key, value);
PlayerPrefs.Save();
}
private string LoadString(string key)
{
return PlayerPrefs.GetString(key);
}
}

Теперь разберем, как использовать эти методы в вашей игре:

1. Создаем объекты, которые нужно сохранить, например, имя игрока или уровень качества графики.
2. Вызываем метод SaveInt или SaveString для сохранения этих значений.
3. Для чтения сохраненных данных используем методы LoadInt и LoadString.

Пример использования в игровом скрипте:

public class GameManager : MonoBehaviour
{
private SaveLoadManager saveLoadManager;
private void Start()
{
saveLoadManager = new SaveLoadManager();
// Сохраняем имя игрока и уровень графики
saveLoadManager.SaveString("PlayerName", "Player1");
saveLoadManager.SaveInt("GraphicsQuality", 2);
string playerName = saveLoadManager.LoadString("PlayerName");
int graphicsQuality = saveLoadManager.LoadInt("GraphicsQuality");
Debug.Log("Player Name: " + playerName);
Debug.Log("Graphics Quality: " + graphicsQuality);
}
}

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

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

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

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

• Простота использования: PlayerPrefs предоставляют удобный способ сохранять переменные и значения через несколько строк кода. Это значит, что вы можете легко и быстро сохранять данные, не углубляясь в сложные механизмы сериализации.
• Многоплатформенность: PlayerPrefs поддерживаются на разных платформах, таких как Windows, macOS, iOS и Android. Это позволяет создавать кроссплатформенные проекты без необходимости изменять подход к хранению данных.
• Поддержка примитивных типов: Вы можете сохранять значения таких типов, как int, float и string. Это покрывает большинство основных потребностей по сохранению данных в игре.

Недостатки

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

Если вам нужен пример, как использовать PlayerPrefs, рассмотрим следующий код. Предположим, мы создаем класс SaveLoadManager, который будет отвечать за сохранение и загрузку игровых данных:

public class SaveLoadManager : MonoBehaviour {
private string playerName = "PlayerName";
private int playerScore = 0;
public void SaveData() {
PlayerPrefs.SetString("name", playerName);
PlayerPrefs.SetInt("score", playerScore);
PlayerPrefs.Save();
}
public void LoadData() {
if (PlayerPrefs.HasKey("name")) {
playerName = PlayerPrefs.GetString("name");
playerScore = PlayerPrefs.GetInt("score");
}
}
public void ResetData() {
PlayerPrefs.DeleteAll();
}
}

В этом примере мы сохраняем и загружаем имя и очки игрока, используя ключи name и score. Метод ResetData удаляет все сохраненные данные. Такая последовательность методов позволяет легко управлять сохраненными данными.

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

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

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

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

[System.Serializable]
public class PlayerData
{
public Vector3 position;
public string name;
public int score;
}

Теперь нам нужно создать скрипт, который будет управлять процессом записи и чтения данных. Этот скрипт будет использоваться на объекте GameController. Добавим метод SaveData для записи данных в файл и метод LoadData для их чтения:

using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using UnityEngine;
public class GameController : MonoBehaviour
{
private string savePath;
void Awake()
{
savePath = Application.persistentDataPath + "/playerdata.dat";
}
public void SaveData(PlayerData data)
{
BinaryFormatter formatter = new BinaryFormatter();
using (FileStream file = File.Create(savePath))
{
formatter.Serialize(file, data);
}
}
public PlayerData LoadData()
{
if (File.Exists(savePath))
{
BinaryFormatter formatter = new BinaryFormatter();
using (FileStream file = File.Open(savePath, FileMode.Open))
{
return (PlayerData)formatter.Deserialize(file);
}
}
return null;
}
}

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

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

public class PlayerController : MonoBehaviour
{
private GameController gameController;
private PlayerData playerData;
void Start()
{
gameController = FindObjectOfType();
playerData = gameController.LoadData();
if (playerData != null)
{
transform.position = playerData.position;
// Загрузите другие данные, например, имя и очки
}
else
{
playerData = new PlayerData();
}
}
void Update()
{
if (Input.GetKeyDown(KeyCode.S))
{
playerData.position = transform.position;
// Сохраните другие данные, например, имя и очки
gameController.SaveData(playerData);
}
}
}

В данном примере, когда игрок нажимает клавишу S, мы сохраняем текущую позицию и другие данные игрока. При запуске игры данные загружаются и восстанавливаются из файла.

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

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

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

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

Класс должен содержать сериализуемые переменные, которые представляют состояние игры. Например, если нужно сохранить количество очков, положение игрока и текущий уровень, создаем соответствующие переменные:

[System.Serializable]
public class SaveState {
public int score;
public Vector3 playerPosition;
public int level;
}

Далее, создаем методы для сохранения и загрузки данных. Метод SaveData будет отвечать за сохранение значений в файл, а метод LoadData – за их чтение.

public class SaveLoadManager : MonoBehaviour {
private string filePath;
void Start() {
filePath = Application.persistentDataPath + "/savedGames.json";
}
public void SaveData(SaveState state) {
string json = JsonUtility.ToJson(state);
File.WriteAllText(filePath, json);
}
public SaveState LoadData() {
if (File.Exists(filePath)) {
string json = File.ReadAllText(filePath);
return JsonUtility.FromJson<SaveState>(json);
} else {
return new SaveState();
}
}
}

Теперь, когда методы для сохранения и загрузки данных созданы, интегрируем их в игровую логику. Например, вызываем SaveData при необходимости сохранения прогресса и LoadData – при загрузке игры. Ниже представлен пример использования этих методов в игровом процессе:

public class GameController : MonoBehaviour {
private SaveLoadManager saveLoadManager;
private SaveState currentState;
void Start() {
saveLoadManager = GetComponent<SaveLoadManager>();
currentState = saveLoadManager.LoadData();
ApplyState(currentState);
}
void ApplyState(SaveState state) {
// Применяем сохраненные значения к игровым объектам
// Пример: игроку, уровню и очкам
}
public void SaveGame() {
currentState.score = // текущее количество очков
currentState.playerPosition = // текущее положение игрока
currentState.level = // текущий уровень
saveLoadManager.SaveData(currentState);
}
}

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

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

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

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

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

• Объявление переменных: Переменные, которые будут сохраняться, должны быть объявлены как public или [SerializeField], чтобы к ним был доступ в процессе сериализации. Например:

  public int score;
  [SerializeField] private Vector3 playerPosition;

• Создание класса данных: Для хранения сохраненной информации создайте специальный класс, который будет содержать все необходимые данные. Например, класс SaveData:

  public class SaveData {
  public int score;
  public Vector3 playerPosition;
  }

• Экземпляры и ключи: Для сохранения и чтения данных из файла или PlayerPrefs, нам понадобятся экземпляры классов и уникальные ключи, чтобы идентифицировать сохраненные значения:

  SaveData currentSave = new SaveData();
  string saveKey = "gameSaveKey";

• Создание методов для сохранения и загрузки: Напишите методы SaveGame и LoadGame в классе SaveLoadManager, которые будут отвечать за сериализацию и десериализацию данных:

  public void SaveGame() {
  SaveData saveData = new SaveData();
  saveData.score = score;
  saveData.playerPosition = playerPosition;
  string json = JsonUtility.ToJson(saveData);
  PlayerPrefs.SetString(saveKey, json);
  PlayerPrefs.Save();
  }
  public void LoadGame() {
  if (PlayerPrefs.HasKey(saveKey)) {
  string json = PlayerPrefs.GetString(saveKey);
  SaveData saveData = JsonUtility.FromJson<SaveData>(json);
  score = saveData.score;
  playerPosition = saveData.playerPosition;
  }
  }

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

  PlayerPrefs.DeleteAll();

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

Видео:

Как сделать сохранения для твоей игры на Unity. PlayerPrefs