Сохранения unity как изменить

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

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

Подготовка

Unity предлагает сразу два способа сохранять игровые данные – попроще и посложнее:

• Попроще – встроенная система PlayerPrefs. Устанавливаете значение для ключа, нажимаете Save – и все готово.
• Посложнее – сериализация данных и запись в файл для дальнейшего использования.

У обоих методов есть преимущества и недостатки, поэтому для конкретного случая важно выбрать правильный вариант. Для демонстрации нам потребуется некоторая минимальная конфигурация. Создадим новый проект в Unity, за основу для простоты возьмем 2D-шаблон.

Добавим два скрипта – SavePrefs и SaveSerial – для реализации двух методов.

Чтобы создать скрипт, кликните правой кнопкой мыши в окне Assets и выберите пункты Create -> C# Script.

Начнем с более простого способа – SavePrefs.

Кликните два раза по скрипту, чтобы открыть его в редакторе Visual Studio.

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

Для начала можно закомментировать или удалить методы Start и Update, так как они не потребуются для демонстрации сохранения данных. Затем нам понадобятся несколько переменных.

        int intToSave;
float floatToSave;
string stringToSave = "";
    

С помощью метода OnGui создадим пользовательский интерфейсдля визуального управления этими переменными.

• Две кнопки – для увеличения значений intToSave и floatToSave.
• Текстовое поле – для переменной stringToSave.
• Несколько лейблов для отображения текущих значений переменных.
• Три кнопки действий, чтобы сохранить, загрузить и сбросить данные.

        void OnGUI()
{
  if (GUI.Button(new Rect(0, 0, 125, 50), "Raise Integer"))
    intToSave++;
  if (GUI.Button(new Rect(0, 100, 125, 50), "Raise Float"))
    floatToSave += 0.1f;

  stringToSave = GUI.TextField(new Rect(0, 200, 125, 25), stringToSave, 15);

  GUI.Label(new Rect(375, 0, 125, 50), "Integer value is " 
    + intToSave);
  GUI.Label(new Rect(375, 100, 125, 50), "Float value is "
    + floatToSave.ToString("F1"));
  GUI.Label(new Rect(375, 200, 125, 50), "String value is " 
    + stringToSave);

  if (GUI.Button(new Rect(750, 0, 125, 50), "Save Your Game"))
    SaveGame();
  if (GUI.Button(new Rect(750, 100, 125, 50), "Load Your Game"))
    LoadGame();
  if (GUI.Button(new Rect(750, 200, 125, 50), "Reset Save Data"))
    ResetData();
}
    

Сохранение

Создадим метод SaveGame, который будет отвечать за сохранение данных:

        void SaveGame()
{
  PlayerPrefs.SetInt("SavedInteger", intToSave);
  PlayerPrefs.SetFloat("SavedFloat", floatToSave);
  PlayerPrefs.SetString("SavedString", stringToSave);
  PlayerPrefs.Save();
  Debug.Log("Game data saved!");
}
    

Как видим, для сохранения данных с PlayerPrefs нужно лишь несколько строчек кода. Здесь мы устанавливаем ключи настройки ("SavedInteger" или "SavedFloat") и их значения передаем в соответствующие методы объекта PlayerPrefs. После того, как все нужные данные записаны, сохраняем их, вызвав метод PlayerPrefs.Save. Выводим сообщение в отладочную консоль, о том, что операция успешно выполнена.

Должно быть, вам интересно, где сейчас физически находятся эти данные. Они записываются в файл в папке проекта. В Windows его можно найти по адресу HKEY_CURRENT_USERSoftwareUnityUnityEditor[company name][project name]. Именно отсюда запускается игра из редактора. В exe-файле их можно найти по адресу HKEY_CURRENT_USERSoftware[company name][project name]. На Mac OS согласно документации файлы PlayerPrefs находятся в папке ~/Library/Preferences, в файле с названием unity.[company name].[product name].plist.

Загрузка

Загрузка сохраненных данных – это, по сути, сохранение наоборот. Необходимо взять значения, хранящиеся в PlayerPrefs и записать их в переменные.

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

Если данных нет, выведем в консоль сообщение об ошибке.

        void LoadGame()
{
  if (PlayerPrefs.HasKey("SavedInteger"))
  {
    intToSave = PlayerPrefs.GetInt("SavedInteger");
    floatToSave = PlayerPrefs.GetFloat("SavedFloat");
    stringToSave = PlayerPrefs.GetString("SavedString");
    Debug.Log("Game data loaded!");
  }
  else
    Debug.LogError("There is no save data!");
}
    

Сброс

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

        void ResetData()
{
  PlayerPrefs.DeleteAll();
  intToSave = 0;
  floatToSave = 0.0f;
  stringToSave = "";
  Debug.Log("Data reset complete");
}
    

В методе ResetData мы очищаем хранилище, а также обнуляем все переменные.

Теперь проверим весь этот код в деле. Сохраните файл и вернитесь в редактор Unity. Прикрепите скрипт SavePrefs к какому-нибудь объекту, например, к Main Camera.

***

Теперь запустите игру и начните взаимодействовать с GUI-элементами. Изменяйте переменные, нажимая на кнопки и заполняя текстовое поле. Когда будете готовы, сохраните данные кнопкой Save Your Game. После этого остановите и перезапустите игру и нажмите на кнопку Load Your Game. Если вы всё сделали правильно, значения переменных немедленно изменятся на те, что вы сохранили в предыдущем запуске.

Чтобы очистить PlayerPrefs, кликните Reset Save Data.

Недостатки

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

Из-за его невысокой безопасности. Вы точно не захотите сохранять таким способом данные, в которые не должен вмешиваться игрок: например, количество доступной игроку игровой валюты, или статистика.

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

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

К счастью, у нас есть еще один способ, более гибкий и безопасный.

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

Для демонстрации сложного способа сохранения данных в Unity откроем скрипт SaveSerial.

Снова определим переменные и создадим интерфейс для управления ими. Метод OnGUI похож на тот, что мы только что писали:

        int intToSave;
float floatToSave;
bool boolToSave;

void OnGUI()
{
  if (GUI.Button(new Rect(0, 0, 125, 50), "Raise Integer"))
    intToSave++;
  if (GUI.Button(new Rect(0, 100, 125, 50), "Raise Float"))
    floatToSave += 0.1f;
  if (GUI.Button(new Rect(0, 200, 125, 50), "Change Bool"))
    boolToSave = boolToSave ? boolToSave = false : boolToSave = true;

  GUI.Label(new Rect(375, 0, 125, 50), "Integer value is " 
    + intToSave);
  GUI.Label(new Rect(375, 100, 125, 50), "Float value is " 
    + floatToSave.ToString("F1"));
  GUI.Label(new Rect(375, 200, 125, 50), "Bool value is " 
    + boolToSave);

  if (GUI.Button(new Rect(750, 0, 125, 50), "Save Your Game"))
    SaveGame();
  if (GUI.Button(new Rect(750, 100, 125, 50), "Load Your Game"))
    LoadGame();
  if (GUI.Button(new Rect(750, 200, 125, 50), "Reset Save Data"))
    ResetData();
}
    

Для сериализации данных потребуется добавить несколько директив using:

        using System;
using System.Runtime.Serialization.Formatters.Binary;
using System.IO;
    

Сохранение

Создадим новый сериализуемый класс SaveData, который будет содержать сохраняемые данные.

        [Serializable]
class SaveData
{
  public int savedInt;
  public float savedFloat;
  public bool savedBool;
}
    

Обратите внимание, три переменные в классе SaveData соответствуют переменным из класса SaveSerial. Для сохранения мы будем передавать значения из SaveSerial в SaveData, а затем сериализовать последний.

Добавим в класс SaveSerial метод SaveGame:

        void SaveGame()
{
  BinaryFormatter bf = new BinaryFormatter(); 
  FileStream file = File.Create(Application.persistentDataPath 
    + "/MySaveData.dat"); 
  SaveData data = new SaveData();
  data.savedInt = intToSave;
  data.savedFloat = floatToSave;
  data.savedBool = boolToSave;
  bf.Serialize(file, data);
  file.Close();
  Debug.Log("Game data saved!");
}
    

Объект BinaryFormatter предназначен для сериализации и десериализации. При сериализации он отвечает за преобразование информации в поток бинарных данных (нулей и единиц).

FileStream и File нужны для создания файла с расширением .dat. Константа Application.persistentDataPath содержит путь к файлам проекта: C:Users[user]AppDataLocalLow[company name].

В методе SaveGame создается новый экземпляр класса SaveData. В него записываются текущие данные из SaveSerial, которые нужно сохранить. BinaryFormatter сериализует эти данные и записывает их в файл, созданный FileStream. Затем файл закрывается, в консоль выводится сообщение об успешном сохранении.

Загрузка

Метод LoadGame – это, как и раньше, SaveGame наоборот:

        void LoadGame()
{
  if (File.Exists(Application.persistentDataPath 
    + "/MySaveData.dat"))
  {
    BinaryFormatter bf = new BinaryFormatter();
    FileStream file = 
      File.Open(Application.persistentDataPath 
      + "/MySaveData.dat", FileMode.Open);
    SaveData data = (SaveData)bf.Deserialize(file);
    file.Close();
    intToSave = data.savedInt;
    floatToSave = data.savedFloat;
    boolToSave = data.savedBool;
    Debug.Log("Game data loaded!");
  }
  else
    Debug.LogError("There is no save data!");
}
    

• Сначала ищем файл с сохраненными данными, который мы создали в методе SaveGame.
• Если он существует, открываем его и десериализуем с помощью BinaryFormatter.
• Передаем записанные в нем значения в переменные класса SaveSerial.
• Выводим в отладочную консоль сообщение об успешной загрузке.

Если файла с данными не окажется в папке проекта, выведем в консоль сообщение об ошибке.

Сброс

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

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

Если файла нет, выводим сообщение об ошибке.

        void ResetData()
{
  if (File.Exists(Application.persistentDataPath 
    + "/MySaveData.dat"))
  {
    File.Delete(Application.persistentDataPath 
      + "/MySaveData.dat");
    intToSave = 0;
    floatToSave = 0.0f;
    boolToSave = false;
    Debug.Log("Data reset complete!");
  }
  else
    Debug.LogError("No save data to delete.");
}
    

***

Скрипт метода сериализации готов, теперь его можно проверить в деле. Сохраните код, вернитесь в Unity и запустите игру. Привяжите скрипт SaveSerial к объекту Main Camera (не забудьте деактивировать предыдущий).

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

В этот раз файл будет сохранен по «постоянному пути данных» игры. В Windows это C:UsersusernameAppDataLocalLowproject name, в Mac – ~/Library/Application Support/companyname/productname согласно документации.

Перезапустите игру и загрузите данные, нажав на кнопку Load Your Game. Значения переменных должны измениться на те, что вы сохранили ранее.

Также вы можете удалить все сохраненные данные кнопкой Reset Save Data.

Заключение

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

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

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

Какие именно данные сохранять и каким способом – зависит от особенностей проекта.

Unity categorizes most saved information into either scene changes or project-wide changes.

• To save all current scene and project-wide changes, go to File > Save (or Save as).
• To save Project-wide changes, but not Scene changes, go to File > Save Project.

Note: If you edit in Prefab Mode, saving through File > Save only saves changes to the open Prefab. Exit the Prefab Mode to save wider changes.

Unity saves some information automatically while you work in the Editor. See Automatic saves for more details.

Scene changes

Scene changes include modifications to GameObjectsThe fundamental object in Unity scenes, which can represent characters, props, scenery, cameras, waypoints, and more. A GameObject’s functionality is defined by the Components attached to it. More info
See in Glossary in the SceneA Scene contains the environments and menus of your game. Think of each unique Scene file as a unique level. In each Scene, you place your environments, obstacles, and decorations, essentially designing and building your game in pieces. More info
See in Glossary. For example:

• If you add, move, or delete a GameObject.
• If you change a GameObject’s parameters in the InspectorA Unity window that displays information about the currently selected GameObject, asset or project settings, allowing you to inspect and edit the values. More info
  See in Glossary window.

Project-wide changes

Project-wide changes in Unity apply to your entire project rather than a specific scene. For example, if you create a temporary scene to test changes, you can save the project and not the scene.

Project-wide changes include:

• Project SettingsA broad collection of settings which allow you to configure how Physics, Audio, Networking, Graphics, Input and many other areas of your project behave. More info
  See in Glossary: When you save your project, Unity saves changes to the Project Settings in the Library folder, in these files:

  • Input: InputManager.asset
  • Tags And Layers: TagManager.asset
  • Audio: AudioManager.asset
  • Time: TimeManager.asset
  • Player: ProjectSettings.asset
  • Physics: DynamicsManager.asset
  • Physics 2D: Physics2DSettings.asset
  • Quality: QualitySettings.asset
  • Graphics: GraphicsSettings.asset
  • Network: NetworkManager.asset
  • Editor: EditorUserSettings.asset

• Build Settings: Unity saves changes to the Build Settings in the Library folder as EditorBuildSettings.asset.

• Changed assets: When you save project-wide settings, Unity saves any unsaved assets.

  Note: Some asset types have an Apply button in the Inspector. Unity will not save these unless you select Apply.

• Dirty assets: Unity saves Dirty assets, which are files on your disk that are modified in the software but not saved yet. You can use custom Editors and scriptsA piece of code that allows you to create your own Components, trigger game events, modify Component properties over time and respond to user input in any way you like. More info
  See in Glossary to mark an Asset as dirty in one of these ways:

  • Use the SerializedObject class with SerializedProperties.
  • Use the Undo class to record modifications.
  • Use SetDirty.

Automatic saves

Unity automatically saves the following changes to your disk:

• New assets: Unity automatically saves new assets when you create them but you need to save later changes.
• Asset Import Settings: For the changes to take effect with most assets, you need to select Apply in the Inspector window. Unity saves the changes when you select Apply.
• Baked data: When you have data that is set to Baked in your project, Unity saves this data after the bake finishes. This includes:
  • Baked Lighting data
  • Baked navigation data
  • Baked occlusion cullingA that disables rendering of objects when they are not currently seen by the camera because they are obscured (occluded) by other objects. More info
    See in Glossary data
• Script execution order changes: After you select Apply, Unity saves this data into each script’s .meta file.

Если вы пишете не казуалку под веб и не беспощадный суровый рогалик, без сохранения данных на диск не обойтись.
Как это делается в Unity? Вариантов тут достаточно — есть класс PlayerPrefs в библиотеке, можно сериализовать объекты в XML или бинарники, сохранить в *SQL*, можно, в конце-концов, разработать собственный парсер и формат сохранения.
Рассмотрим поподробнее с первые два варианта, и заодно попробуем сделать меню загрузки-сохранения со скриншотами.

Будем считать, что читающий дальше базовыми навыками обращения с этим движком владеет. Но при этом можно не подозревать о сущестовании в его библиотеке PlayerPrefs, GUI, и ещё в принципе не знать о сериализации. С этим всем и разберёмся.
А чтобы эта заметка не стала слишком уж увлекательной и полезной, ориентирована она самый неактуальный в мобильно/планшетно/онлайновый век вариант — сборку под винду (хотя, конечно, более общих моментов достаточно).

• Кстати, пару недель назад на Хабре была статья, где автор упомянул, что Unity3D проходят в курсе компьютерной графики на кафедре информатики питерского матмеха. Занятный факт, немало говорящий о популярности движка.
  Хотя насколько это в целом хорошая идея — на мой взгляд, тема для дискуссии. Может быть, обсудить это было бы даже интереснее вопросов сериализации =)

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

1. PlayerPrefs

Удобный встроенный класс. Работает с int, float и string. Довольно прозрачный, но мне всё равно встречались на форумах обороты в духе «не могу понять PlayerPrefs» или «надо бы как-нибудь разобраться с PlayerPrefs», так что посмотрим на него на простом примере.

1.1 Примитивное использование в рамках одной сцены: QuickSave & QuickLoad по хоткеям.

Быстрый пример использования. Допустим, у нас одна сцена и персонаж на ней. Скрипт SaveLoad.cs прикреплен к персонажу. Будем сохранять самое простейшее — его положение.

using UnityEngine;
using System.Collections;

public class SaveLoad : MonoBehaviour {

	public Transform CurrentPlayerPosition;
	
	void Update () {
		
		if(Input.GetKeyDown(KeyCode.R))
			savePosition();
		
		if(Input.GetKeyDown(KeyCode.L))
			if (PlayerPrefs.HasKey("PosX"))  // проверяем, есть ли в сохранении подобная информация
				loadPosition();

		if(Input.GetKeyDown(KeyCode.D))
			PlayerPrefs.DeleteAll();	// очистка всей информации для этого приложения
	}

	public void savePosition(){
		
		Transform CurrentPlayerPosition = this.gameObject.transform;
		
		PlayerPrefs.SetFloat("PosX", CurrentPlayerPosition.position.x); // т.к. автоматической работы 
		PlayerPrefs.SetFloat("PosY", CurrentPlayerPosition.position.y); // с массивами нет, разбиваем на
		PlayerPrefs.SetFloat("PosZ", CurrentPlayerPosition.position.z);  // отдельные float и записываем
		
		PlayerPrefs.SetFloat("AngX", CurrentPlayerPosition.eulerAngles.x); 
		PlayerPrefs.SetFloat("AngY", CurrentPlayerPosition.eulerAngles.y);
		
		PlayerPrefs.SetString("level", Application.loadedLevelName); // ещё можно писать/читать строки
		PlayerPrefs.SetInt("level_id", Application.loadedLevel); // и целые
	}
	
	public void loadPosition(){
	
		Transform CurrentPlayerPosition = this.gameObject.transform;
	
		Vector3 PlayerPosition = new Vector3(PlayerPrefs.GetFloat("PosX"), 
					PlayerPrefs.GetFloat("PosY"), PlayerPrefs.GetFloat("PosZ"));
		Vector3 PlayerDirection = new Vector3(PlayerPrefs.GetFloat("AngX"), // генерируем новые вектора 
					PlayerPrefs.GetFloat("AngY"), 0);  // на основе загруженных данных
	
		CurrentPlayerPosition.position = PlayerPosition; // и применяем их
		CurrentPlayerPosition.eulerAngles = PlayerDirection;
	}
}

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

Зато весь основной интерфейс класса виден: для каждого из трех типов Get / Set по ключу, проверка вхождения по ключу, очистка. Нет смысла даже разбирать ScriptReference, всё очевидно по названиям функций: PlayerPrefs

Однако на одной всё же стоит остановиться подробнее, PlayerPrefs.Save. В описании говорится, что вообще дефолтно юнити пишет PlayerPrefs на диск только при закрытии приложения — в общем-то логично, учитывая, что класс ориентирован не на внутренний обмен данными, и на их сохранение между сеансами. Соответственно, Save() предполагается использовать только для периодических сохранений на случай крэша.

Возможно, в некоторых случаях это так и работает. Под Win PlayerPrefs пишутся в реестр, и, как можно легко убедиться, считываются и пишутся сразу.
Как-то так выглядит наш класс в реестре:

Ко всем ключам в конце добавлен их DJBX33X-хеш (Bernshtein hash with XOR).

UnityGraphicsQuality сохраняется всегда автоматически, и действительно при закрытии приложения. Это Quality level из Edit -> Project Settings Quality, оно же QualitySettings.SetQualityLevel.

Можно при запущенном приложении модифицировать сохранённое значение в реестре, потом затребовать его из программы — и мы увидим, что вернулся модифицированный вариант. Т.е. не стоит думать что во время работы программы PlayerPrefs — что-то вроде аналога глобальных переменных, а работа с диском не происходит.

2. Сериализация в XML

Говорим сериализация, подразумеваем бинарный код. Такое встречается, но на самом деле сериализовать можно в любой формат. По сути это перевод структуры данных или состояния объекта в хранимый/передаваемый формат. А десериализация, соответственно — восстановление объекта по сохраненным/полученным данным.

Вообще Mono умеет и бинарную сериализацию, и XML (System.Xml.Serialization), но есть один момент: большинство классов Unity не сериализуются напрямую. Невозможно просто взять и сериализовать GameObject, или класс, наследующий MonoBehavoir: придётся завести дополнительно внутренний сериализуемый класс, содержащий нужные данные, и работаеть, используя его. Но XmlSerializer хотя бы кушает автоматически Vector3, а BinarySerializer, afaik, даже этого не умеет.

2.1 Суть примера

Представьте, что вы пишете свой Portal, где герой проходит череду однотипных локаций — но на любую из них может впоследствии вернуться. Причём на каждую он мог оказать воздействие: какие-то ресурсы использовать, что-то сломать, что-то расшвырять. Хочется, эти изменения сохранять, но возвращение на локацию маловероятно и непрогнозируемо, и тащить за собой параметры всех комнат в оперативке нет особого смысла. Будем сериализовать локацию, покидая её — например, по триггеру на двери. А при загрузке локации генерировать либо дефолтную ситуацию, либо, если есть сохраненные данные, восстанавливать по ним.

2.2 Сериализуемые классы для данных

XmlSerializer умеет работать с классами, данные в которых состоят из других сериализуемых классов, простых типов, большинства элементов Collections[.Generic]. Обязательно наличие у класса пустого конструктора и public-доступ ко всем сериализуемым полям.
Некторые типы из библиотеки Юнити (вроде Vector3, содержащего всего три интовых поля) успешно проходят этот фейсконтроль, но большинство, особенно более сложных, его фейлят.

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

Создадим новый скрипт в Standard Assets:

using UnityEngine;
using System.Collections.Generic;
using System.Xml.Serialization; 
using System;


[XmlRoot("RoomState")]
[XmlInclude(typeof(PositData))] 
public class RoomState {		//  класс, содержащий состояние комнаты в целом

	[XmlArray("Furniture")]
	[XmlArrayItem("FurnitureObject")]
	public List<PositData> furniture = new List<PositData>(); // список из перемещаемых предметов

	public RoomState() { }   // пустой конструктор

	public void AddItem(PositData item) {	// добавление элементов - будем этим пользоваться
		furniture.Add(item);			// при генерации дефолтной версии локации
	}
	
	public void Update(){    // функция, по которой данные этого класса-дубликата объектов 
		foreach (PositData felt in furniture) // будут обновляться
			felt.Update();		
	}
}

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

Дальше там же добавим базовый класс для предметов из списка и сколько угодно наcледуемых от него. Хотя… для примера хватит и одного:

[XmlType("PositionData")]
[XmlInclude(typeof(Lamp))] 
public class PositData
{
	protected GameObject _inst;	// тут храним ссылку на отражаемый объект
	public GameObject inst { set { _inst = value; } }
	
	[XmlElement("Type")]
	public string Name { get; set; }  // это будет название префаба из Resourses
	
	[XmlElement("Position")]
	public Vector3 position {get; set; } 
	
	public PositData() { }
	
	public PositData(string name, Vector3 position)
	{
		this.Name = name;
		this.position = position;
	}
	
	public virtual void Estate(){  }   // для "доработки" объекта после создания
	
	public virtual void Update(){  // обновление нашего рефлектора
		position = _inst.transform.position;  // согласно реальной информации об объекте
	}
	
}

[XmlType("Lamp")] 
public class Lamp : PositData   // лампочка, кроме положения, может ещё быть вкл/выкл
{	
	[XmlAttribute("Light")]
	public bool lightOn { get; set; }
	
	public Lamp() { }
	
	public Lamp(string name, Vector3 position, bool lightOn): base(name, position) {
		this.lightOn = lightOn;
	}
	
	public override void Estate(){
		if (!lightOn) ((Light)(_inst.GetComponentInChildren(typeof(Light)))).enabled = false;
	}		// исходим из того, что в префабе компонент Light включен 
	
	public override void Update(){
		base.Update();
		lightOn = ((Light)_inst.GetComponentInChildren(typeof(Light))).enabled;
	}  // lightOn = включен ли компонент Light на лампе
}

Итак, сериализуемые классы готовы. Сделаем теперь ещё класс для дополнительного упрощения сериализации созданного типа RoomState.

2.3 Непосредственно сериализация

Тоже в Standard Assets сделаем класс с парой статических методов, которыми будем в дальнейшем пользоваться:

using System.Xml.Serialization; 
using System;
using System.IO; 
	
public class Serializator {
	
	static public void SaveXml(RoomState state, string datapath){

		Type[] extraTypes= { typeof(PositData), typeof(Lamp)};
		XmlSerializer serializer = new XmlSerializer(typeof(RoomState), extraTypes); 

		FileStream fs = new FileStream(datapath, FileMode.Create); 
		serializer.Serialize(fs, state); 
		fs.Close(); 

	}
	
	static public RoomState DeXml(string datapath){

		Type[] extraTypes= { typeof(PositData), typeof(Lamp)};
		XmlSerializer serializer = new XmlSerializer(typeof(RoomState), extraTypes); 
		
		FileStream fs = new FileStream(datapath, FileMode.Open); 
		RoomState state = (RoomState)serializer.Deserialize(fs); 
		fs.Close(); 

		return state;
	}
}

Здесь XmlSerializer мы создаём через конструктор Constructor (Type, Type[])
FileStream открываем по адресу сохранения, передаваемого конкретной локацией.

Использование

Итак, все вспомогательные инструменты готовы, можно приступать к самой комнате. На объект комнаты вешаем:

public class RoomGen : MonoBehaviour {

	private RoomState state;	// отражающий класс
	private string datapath;	// путь к файлу сохранения для этой локации
	
	void Start () {
		datapath = Application.dataPath + "/Saves/SavedData" + Application.loadedLevel + ".xml";

		if (File.Exists(datapath))	// если файл сохранения уже существует
			state = Serializator.DeXml(datapath);  // считываем state оттуда
		else 
			setDefault();		// иначе задаём дефолт
		
		Generate();	// 	генерируем локацию по информации из state
		
	}
	
	void setDefault(){	
		state = new RoomState();
		// chair, table, lamp - нужные префабы из Resourses
		state.AddItem(new PositData("chair", new Vector3(15f, 1f, -4f)));
		state.AddItem(new PositData("chair", new Vector3(10f, 1f, 0f)));
		state.AddItem(new PositData("table", new Vector3(5f, 1f, 4f)));
		state.AddItem(new Lamp("lamp", new Vector3(5f, 4f, 4f), true));

	}
	
	void Generate(){
		foreach (PositData felt in state.furniture){  // для всех предметов в комнате
			felt.inst = Instantiate(Resources.Load(felt.Name), felt.position, Quaternion.identity) as GameObject;
			// овеществляем их
			felt.Estate(); // и задаём дополнительные параметры
		}				
	}
	
	void Dump() {
		state.Update(); // вызов обновления state
        	Serializator.SaveXml(state, datapath); // и его сериализация
	}
}

Напоследок, сделаем вызов RoomGen.Dump(). Пусть, например, по триггерам на дверях, которые являются дочерними объектами относительно комнаты (объекта с компонентом RoomGen):

using UnityEngine;
using System.Collections;

public string nextRoom;

public class Door : MonoBehaviour {
	
	void OnTriggerEnter(Collider hit)
	{
		
		if (hit.gameObject.tag == "Player")
		{
			SendMessageUpwards("Dump");
			Application.LoadLevel(nextRoom);
		}
	}
}

Вот и всё. Здесь опущено собственно взаимодействие с предметами и процесс изменения их состояния, но это несложно добавить. Для первоначального теста можно просто добавить в скрипт пару устанавливащих состояния функций по хоткеям, или ставить на паузу и двигать руками.

При первом запуску генерируется дефолтный вариант, при выходе изменения дампятся в файл, при возвращении последние состояние восстанавливается из файла, в том числе если приложение закрывалось. Works like a charm.

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

3. Save/Load через меню

Наверное, актуальнее было бы реализовать вариант с выбором/созданием пользователя и внутренними автоматическими сохранениями. Если вашей игре требуется серьёзное меню Save/Load, то вряд ли вы сейчас читаете эту статейку для профанов.

Но я жду не дождусь новогодних праздников, когда можно будет наконец увидеться с сестрой и за пару вечеров добить классическую American McGee’s Alice, так что сделаем Save/Load почти как там. Со скриншотами. Заодно будет повод покопаться в GUI, текстурах и других увлекательных вещах.

3.1 Главное меню

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

• Scripting Reference
  Для начала пригодятся:
  OnGUI() — функция MonoBehaviour для отрисовки GUI и обработки связанных с ним событий. Нечто вроде Update(), но специально для GUI и вызываться может чаще, чем каждый фрейм.

  GUI.Button

  static bool Button(Rect position, String text);
  static bool Button(Rect position, Textureimage );
  

  функция кнопки. Рисует её в рамках заданного прямоугольника, реагирует на нажатие, возвращая true. Конструкторов больше, но нам хватит этих.

  GUI.BeginGroup, GUI.EndGroup

  static void BeginGroup (Rect position);
  static void EndGroup ();
  

  Группировка элементов гуи, полезна в основном переопределением границ относительно которых вычисляется положение вложенных элементов (дефолтно это границы экрана, в данном случает — прямоугольник position).

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

public class MenuScript : MonoBehaviour {
	
	public Texture2D backgroundTexture;  	// фон для режима меню
	public const int mainMenuWidth = 200; 	// ширина кнопок в главном меню

	private int menutype = 0; 		// текущий тип меню - пригодится дальше
	private bool menuMode = true;	// включено ли меню
	private bool gameMode = false;	// запущена ли собственно игра -
										// false  только до первого Load / New Game
	private void Awake(){
		DontDestroyOnLoad(this);	 // объект меню не будет разрушаться при загрузке новых сцен
	}

	void Update () {		
			if (Input.GetKeyDown(KeyCode.Escape)){  // warning! Это может быть не совсем очевидно: Input.GetKey()
			
				if(gameMode)	
					if (menutype == 0 || !menuMode){ // если мы в игре или на нижнем уровне меню
						switchGameActivity();		// остановливаем/запускаем игровые события
												//  (в данном случае просто движение камеры)
						menuMode = !menuMode;
					}
				menutype = 0;  // с более глубоких уровней меню возвращает в корень
			}					// из игрового режима грузит главное меню
	}
	
	private void OnGUI(){		
	
		if (menuMode){
			
			if(backgroundTexture != null)		// очевидно, опционально
				GUI.DrawTexture(new Rect(0, 0, Screen.width, Screen.height), backgroundTexture);
			
			switch (menutype){
				case 0: drawMainMenu(); break;
				case 1:
				case 2: drawSaveLoadMenu(); break;
			}
		}
	}

	private void drawMainMenu(){	

		GUI.BeginGroup (new Rect (Screen.width / 2 - mainMenuWidth/2, Screen.height / 2 - 180, mainMenuWidth, 240));
		
			if (gameMode)
				if(GUI.Button(new Rect(0,0, mainMenuWidth,30) , "Resume")){
	        		menuMode = false;
					switchMouseLook();
				}
			
			if(GUI.Button(new Rect(0, 40, mainMenuWidth, 30) , "New Game")){
				menuMode = false;
				gameMode = true;
				Application.LoadLevel("first_scene");
			}
			
			if (gameMode)
				if(GUI.Button(new Rect(0, 2*40, mainMenuWidth, 30) , "Save"))
					menutype = 1;
		
			if(GUI.Button(new Rect(0, ((gameMode)? 3 : 2)*40, mainMenuWidth, 30) , "Load")){ 
				menutype = 2;	// Почему не "2 + gameMode"? C#, nuff said.
		
			if(GUI.Button(new Rect(0, ((gameMode)? 4 : 3)*40, mainMenuWidth, 30) , "Options")){}
			
			if(GUI.Button(new Rect(0, ((gameMode)? 5 : 4)*40, mainMenuWidth, 30) , "Quit Game")){
				Application.Quit();
			}
			
		GUI.EndGroup();	
		
	}

	void switchGameActivity(){	// в данном случае cчитается, что на активной камере есть скрипт MouseLook,
		Camera mk = Camera.main;  // поворачивающий камеру по движению мыши. Вообще тут стоит
		MouseLook ml = mk.GetComponent<MouseLook>();	 //  приостанавливать обработку всех событий ввода
		if (ml != null) ml.enabled = !ml.enabled; 	// и всю динамику
	}
	
}

Главное меню до и после начала игры

3.2 Рисуем меню загрузки / сохранения

Функция drawSaveLoadMenu() у нас уже вызывается при menutype>0, но пока не написана. Исправим это упущение. Пока просто научимся рисовать наши меню и вызывать собственно функции загрузки/сохранения.

• Scripting Reference
  GUI.SelectionGrid — рисует сетку кнопок, но по сути это одновариантый селект. Всегда выбран один вариант, возвращает номер выбранного.

  static int SelectionGrid (Rect position , int defaultSelected, Texture[] images, int elsInRow);
  static int SelectionGrid (Rect position , int defaultSelected, string[] texts, int elsInRow);
  

  Количество — исходя из размеров передаваемого массива. Вообще предназначен для использования как-то так:

  public int selGridInt = 0;  // на старте задаём выбранное по дефолту
  public string[] selStrings = new string[] {"Grid 1", "Grid 2", "Grid 3", "Grid 4"};
  
  void OnGUI() { // и дальше держим и изменяем эту переменную
   	selGridInt = GUI.SelectionGrid(new Rect(25, 25, 100, 30), selGridInt, selStrings, 2); 
  				//  возвращает selGridInt если ничего не произошло, 
   }  		// и индекс нового элемента, если был клик по одному из элементов сетки
  

• Суть
  Кажется, это не совсем то, что нам требуется — нам-то нужно выбрать один раз и сразу отреагировать. Но SelectionGrid спокойно ест грязный хак — индекс вне пределов реального массива. Т.е. мы всегда будем передавать, допустим, -1 и тогда сможем отслеживать собственно событие клика.

public const int slotsAmount = 10;  // количество слотов загрузки/сохранения
									// массив наших скриншотов. подробнее о нём дальше,
private Texture2D[] saveTexture = new Texture2D[slotsAmount]; // пока важно, что если слот содержит 
		//сохранение, то соответствующий элемент массива содержит текстуру в виде скриншота, иначе null
private void drawSaveLoadMenu(){
	
	if(GUI.Button(new Rect(Screen.width / 2 - 100, Screen.height * 2/3 + 50, 200, 30) , "Back"))
		menutype = 0;
	
	int slot = GUI.SelectionGrid(
						new Rect(	// подстраиваем под размер экрана сетку 5x2
								Screen.width / 2 - Screen.height * 5/9, // с соотношением
								Screen.height/3,	// сторон кнопки 4:3
								Screen.height * 10/9,
								Screen.height/3
						),
						-1,  // индекс вне пределов массива
						saveTexture,  // если null, то просто не рисует
						5);  // количество элементов в строке
	
	if (slot >= 0)  // выполнится только в случае клика
		if (menutype == 1) savegame(slot);  	// Если это было меню сохранения - сохраняем
		else if (menutype == 2 && saveTexture[slot] != null) loadgame (slot);
} 	 // Если загрузки и слот не пуст - загружаем. Информацию о функциональности слотов можно хранить отдельно,
 // но тут мы просто воспользовались тем же массивом текстур

Меню Load на SelectionGrid — внешне ничем не отличается от соответствующего Save

Основное, что мне в этом решении не нравится, это что в меню загрузки не содержащие сохранений слоты остаются относительно активными — внешне отличаются только отсутствием текстуры, реагируют на наведение. Поэтому бонусом — сетка ручками, вместо неактивных слотов рисуем Box, для активных Button.
Заодно добавим резиновости: количество слотов в строке задаётся, размер слотов подстраивается под экран. Правда, тут они уже квадратные, но встроить произвольное соотношение сторон будет несложно Ну и заодно min/max width/height из GUILayout и прочая обработка напильником.

public const int slotsAmount = 10;  
public const int hN = 5;	
public const int margin = 20;

static private int vN = (int)Mathf.Ceil((float)slotsAmount/hN);	
private Texture2D[] saveTexture = new Texture2D[slotsAmount];	
private int slotSize = ((Screen.width*vN)/(Screen.height*hN) >= 1) ? Screen.height/(vN + 2) : Screen.width/(hN + 2);

private void drawSaveLoadMenu(){
	
	GUI.BeginGroup (new Rect (	Screen.width / 2 -  (slotSize*hN - margin) / 2,
								Screen.height / 2 - (slotSize*vN - margin) / 2,
								slotSize*hN - margin, slotSize*vN + 40));
	
	for (int j = 0; j < vN; j++)
		for (int i = 0, curr = j*hN; (curr = j*hN + i) < slotsAmount; i++){
			if (menutype == 2 && saveTexture[curr] == null)
				GUI.Box(new Rect(slotSize*i, slotSize*j, slotSize - margin, slotSize - margin), "");
			else 
				if(GUI.Button(new Rect(slotSize*i, slotSize*j, slotSize - margin, slotSize - margin),
															saveTexture[curr])){
					if (menutype == 1) savestuff(curr);
					else if (menutype == 2) loadstuff (curr);
				}				
	}
	
	if(GUI.Button(new Rect(slotSize*hN/2 - 100, slotSize*vN , 200, 30) , "Back"))
		menutype = 0;
	
	GUI.EndGroup();	
}

Меню Load на Button и Box — теперь пустые слоты неактивны

3.3 Текстуры, скриншоты

Итак, с момента создания нашего объекта меню мы будем держать массив текстур. Памяти он занимает немного и нам гарантирован в ним мгновенный доступ. На самом деле, тут и альтернативы особой нет — не пихать же работу с диском в onGUI().

Как мы уже видели, при создании нашего меню создаём и массив:

private Texture2D[] saveTexture = new Texture2D[slotsAmount];

Сохранять мы будем не только информацию сейвов, но и информацию о них, а точнее — какие именно слоты содержат сохранения. Как хранить — выбор каждого, можно по параметру 0/1 на каждый слот, можно строку из 0/1, но мы сделаем некрасиво и возьмём битовый вектор в int. В какой момент и как он сохраняется, увидим позже, пока просто читаем.
Добавим в Start():

int gS = PlayerPrefs.GetInt("gamesSaved");
for (int i = 0; i < slotsAmount && gS > 0; i++, gS/=2) 
	if (gS%2 != 0){
		saveTexture[i] = new Texture2D(Screen.width/4, Screen.height/4);  // тут тот же размер, в котором пишем на диск
		saveTexture[i].LoadImage(System.IO.File.ReadAllBytes(Application.dataPath + "/tb/Slot" + i + ".png"));
	} 	// и адрес, конечно, тоже совпадает с тем, куда сохраняем.

Ну и собственно главное в данном вопросе — как скрины сохранять? Напрашивается вариант Application.CaptureScreenshot, но тут сразу два подвоха. Во-первых, они сохраняются в полном размере, а поскольку в кончном итоге понадобятся нам только thumbnails, логичнее сразу сделать ресайз. Во-вторых, мы же держим массив текстур, придётся в него снова считывать с диска? Не очень-то здорово.

Функцию взятия и записи скриншота вызывать будем позже, а пока заранее выделим в Coroutine:

IEnumerator readScreen(int i){
	
	yield return new WaitForEndOfFrame(); // так мы и избежим ошибок, и не заскриншотим само меню сохранения :)
	
	int adjustedWidth = Screen.height * 4/3; // допустим, мы хотим держать определенное соотношение сторон
	Texture2D tex1 = new Texture2D(adjustedWidth, Screen.height);
	// кропаем в свежесозданную текстуру нужный участок экрана
	tex1.ReadPixels(new Rect((Screen.width - adjustedWidth)/2, 0, adjustedWidth, Screen.height), 0, 0, true);
	tex1.Apply();

	//создаем новую текстуру нужного размера
	Texture2D tex = new Texture2D(Screen.height/3, Screen.height/4, TextureFormat.RGB24, true);
	tex.SetPixels(tex1.GetPixels(2)); // и применяем наш суровый и беспощадный ресайз	
	Destroy(tex1);
	tex.Apply();
	
	saveTexture[i] = tex;		// сохраняем в массив текстур
	
	FileStream fs = System.IO.File.Open(Application.dataPath + "/tb/Slot" + i + ".png", FileMode.Create); 
	BinaryWriter binary = new BinaryWriter(fs);
	binary.Write(tex.EncodeToPNG());	// и на диск
	fs.Close();

}

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

3.4 Собственно реализация сохранения загрузки

Итак, вроде бы с шелухой разобрались. Научились минимально работе с GUI, сделали простое главное меню, меню Save/Load, научились работать со скриншотами.

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

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

2. GameObject.Find и GameObject.FindWithTag тут использовать практически не стыдно — загрузка/сохранение — разовое событие. Можно искать напрямую, а поскольку сцены могут содержать разную информацию — то, как вариант, добавлять на каждую специальный объект с определенным тегом, к которому и будет прикручен скрипт сохранения/загрузки собственно данной сцены, тут уже можно держать прямые ссылки на требуемые объекты.

3. < место зарезервировано под иные варианты оптимальнее, предлагайте! >

А пока рассмотрим такой простой вариант. Сохранять будем только сцену и положение игрока. Игрок в каждой сцене пересоздаётся, но всегда вид от первого лица, и соответственно к игроку прикреплена камера.
Через неё и будем получать доступ. В ниже представленной функции вся эта специфика — в двух строках помеченных //!, и её не сложно локально заменить, остальное привязано к уже написанному нами выше коду.

void savegame(int i)
{
	
	PlayerPrefs.SetInt("slot" + i + "_Lvl", Application.loadedLevel);  // сохраняем текущий уровень

	// !
	Interface сi = Camera.main.GetComponent<Interface>();
	if (сi != null)  сi.save(i); 	// а основную работу с PlayerPrefs делегируем самому объекту

	menuMode = false; // выходим из меню
	switchGameActivity(); // возобновляем игру

	// немного простой битовой магии. Апдейтим информацию о функциональности слотов.
	// Как уже сказано, можно использовать и более читаемые варианты.
	// в текущей реализации это нам пригодится только при следующем запуске
	PlayerPrefs.SetInt("gamesSaved", PlayerPrefs.GetInt("gamesSaved") | (1 << i));
	
	StartCoroutine(readScreen(i)); // делаем скриншот уже после выхода из меню	
}

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

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

void loadgame(int i)
{
	if (gameMode)	// меню Load доступно сразу, так что тут пригодится проверка
		switchGameActivity();

	PlayerPrefs.SetInt("Load", i); // сохраняем информацию о том, какой слот загружен

	Application.LoadLevel(PlayerPrefs.GetInt("slot" + i + "_Lvl"));  // загружаем нужный уровень

	menuMode = false;
	gameMode = true; // на случай, если игра ещё не запускалась
}

Сделаем теперь поведение, который будем вешать на камеры:

public class Interface : MonoBehaviour {
	
	private Transform CurrentPlayerPosition;

	public virtual void Start () {
		int load = PlayerPrefs.GetInt("Load");  // проверяем, не создан ли объект
		if (load >= 0){  		// в рез-те загрузки сохранения
			load(load);
			PlayerPrefs.SetInt("Load", -1);  // обнуляем Load
		}
	}
	
	public virtual void  save(int i)
	{	// получаем текущую позицию игрока и сохраняем все её параметры
		CurrentPlayerPosition = this.gameObject.transform.parent.transform;
		PlayerPrefs.SetFloat("slot" + i + "_PosX", CurrentPlayerPosition.position.x);
		PlayerPrefs.SetFloat("slot" + i + "_PosY", CurrentPlayerPosition.position.y);
		PlayerPrefs.SetFloat("slot" + i + "_PosZ", CurrentPlayerPosition.position.z);
	}
	
	public virtual void load(int i) {
		CurrentPlayerPosition = this.gameObject.transform.parent.transform; 
		
		// создаем новый вектор на основе загруженных параметров
		Vector3 PlayerPosition = new Vector3(PlayerPrefs.GetFloat("slot" + i + "_PosX"), 
					PlayerPrefs.GetFloat("slot" + i + "_PosY"), PlayerPrefs.GetFloat("slot" + i + "_PosZ"));

		CurrentPlayerPosition.position = PlayerPosition;  // и применяем его, изменяя 
	}		// положение игрока на сохраненное

}

Надо заметить „дальше как-нибудь сами“ было определенной степенью лукавства: loadgame() меню и load() объекта определенно обменялись информацией, только вот через известное место — реестр. Сохранять туда откровенно временную переменную — ход не слишком красивый. Можно изменить на прямой вызов load(), а без изменения текущей общей структуры — держать переменную в меню, и в Start() загружаемого объекта добавить поиск объекта меню и получение нужной информации.

Дальше. От созданного базового поведения мы можем унаследовать разные варианты для разных сцен и объектов. Например, вариант с сохранением поворота:

public class InterfaceWAng : Interface {
	
	public override void Start () {
		base.Start();
	}
	
	public override void save(int i)
	{
		base.save(i);
		PlayerPrefs.SetFloat("slot" + i + "_AngX", CurrentPlayerPosition.eulerAngles.x);
		PlayerPrefs.SetFloat("slot" + i + "_AngY", CurrentPlayerPosition.eulerAngles.y);
	}
	
	public override void load(int i)
	{
		base.load(i);
		Vector3 PlayerDirection = new Vector3(PlayerPrefs.GetFloat("slot" + i + "_AngX"), 
					PlayerPrefs.GetFloat("slot" + i + "_AngY"), 0);

		CurrentPlayerPosition.eulerAngles = PlayerDirection;
	}

}

Конечно, здесь данным уже пригодилась бы защита. Поскольку поскольку вся фактическая работа с PlayerPrefs тут выделена в отдельные функции save() / load(), заменить их содержательную часть будет не сложно. На что? Можно аналогично примеру из части 2 держать класс-рефлектор, и сериализовать его через BinarySerializer.
Другой неплохой вариант — прикрутить, например, SQLite. Правда, по слухам, на js с ней работать удобнее, чем на шарпе, но и на последнем всё в конечном итоге заводится. Кто хочет попробовать, начать можно отсюда.

Этот текст никогда бы не получился без:

гугла
docs.unity3d.com
wiki.unity3d.com
forum.unity3d.com
answers.unity3d.com
stackoverflow.com

и хабра. Спасибо им.
Надеюсь, всё это принесёт кому-нибудь пользу, и никому — вреда

В этом уроке вы узнаете, как сохранять и загружать игру в Unity, используя PlayerPrefs, Serialization и JSON.

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

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

В этом уроке вы узнаете:

• Что такое сериализация и десериализация.
• Что такое PlayerPrefs и как его использовать для сохранения настроек игрока.
• Как создать файл сохранения игры и сохранить его на диск.
• Как загрузить файл сохраненной игры.
• Что такое JSON и как вы можете его использовать.

Предполагается, что у вас есть некоторые базовые практические знания о том, как работает Unity. Однако, если у вас возникнут какие-либо вопросы в ходе прохождения этого урока, то вы всегда можете освежить память воспользовавшись данным разделом. Кроме того, даже если вы новичок в C#, у вас не должно возникнуть никаких проблем, за исключением нескольких концепций, которые могут потребовать более детального изучения.

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

Введение

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

Важные концепции сохранения

Существует четыре ключевых понятия которыми можно охарактеризовать процесс сохранения в Unity:

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

Сериализация: это своего рода магия, которая заставляет Unity корректно работать. Сериализация — это преобразование объекта в поток байтов. Чтобы лучше понимать, о чем идет речь посмотрите на этот рисунок:

Что такое «объект»? В этом случае «объект» — это любой скрипт или файл в Unity. Фактически, всякий раз, когда вы создаете сценарий MonoBehaviour, Unity использует сериализацию и десериализацию для преобразования этого файла в код C++, а затем обратно в код C#, который вы видите в окне inspector.

Примечание: Если вы являетесь Java-разработчиком или веб-разработчиком, возможно, вы знакомы с концепцией, известной как маршалинг. Сериализация и маршалинг являются синонимами, но в случае, однако между этими двумя понятиями существует большая разница. Сериализация подразумевает преобразование объекта из одной формы в другую (например, объект в байты), тогда как маршалинг — это получение параметров из одного места в другое.

Десериализация: Это процесс, противоположный сериализации, а именно преобразование потока байтов в объект.

JSON: Эта аббревиатура расшифровывается как JavaScript Object Notation, который является удобным форматом для отправки и получения данных, вне зависимости от языка. Например, у вас может быть веб-сервер, работающий на Java или PHP. Вы не можете просто отправить объект C#, но вы можете отправить JSON-версию этого объекта и позволить серверу воссоздать его локализованную версию. Вы узнаете больше об этом формате в последнем разделе, но сейчас важно просто понять, что это способ форматирования данных, чтобы сделать их мультиплатформенными для чтения (например, XML). При преобразовании в/и из JSON используются термины JSON-сериализация и JSON-десериализация соответственно.

Player Prefs

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

Откройте проект, который вы скачали, запустите сцену с именем Game и затем нажмите play.

Чтобы начать игру, нажмите кнопку «New Game». В этой игре вам необходимо использовать мышку для перемещения. Нажмите левую кнопку мыши, чтобы выстрелить и поразить цели (которые перемещаются вверх и вниз через различные промежутки времени), получать очки за каждое удачное попадание. Попробуйте и посмотрите, сколько очков вы сможете получить за 30 секунд. Чтобы вызвать меню в любое время, нажмите клавишу escape.

Эта игра довольна забавная и даже увлекательная, но без музыкального сопровождения немного скучновата. Возможно, вы заметили, что есть музыкальный переключатель, но он был выключен. Нажмите «Play», чтобы начать новую игру, но на этот раз нажмите «Music» и установите значение «On», чтобы вы могли услышать музыку, когда начнете игру. Убедитесь, что ваши колонки или наушники подключены!

Изменить настройки музыки было несложно, но если вы нажмете кнопку воспроизведения еще раз, то заметите проблему: музыка больше не воспроизводится. Чтобы исправить эту ошибку вам потребуется инструмент PlayerSettings.

Для начала создайте новый скрипт с именем PlayerSettings в папке Scripts. Поскольку вы будете использовать некоторые элементы пользовательского интерфейса, добавьте следующую строку вверху:

using UnityEngine.UI;

Затем добавьте следующие переменные:

[SerializeField]

private Toggle toggle;

[SerializeField]

private AudioSource myAudio;

Именно они будут отслеживать объекты Toggle и AudioSource.

Далее добавьте следующую функцию:

public void Awake ()

  {

    // 1

    if (!PlayerPrefs.HasKey("music"))

    {

      PlayerPrefs.SetInt("music", 1);

      toggle.isOn = true;

      myAudio.enabled = true;

      PlayerPrefs.Save ();

    }

    // 2

    else

    {

      if (PlayerPrefs.GetInt ("music") == 0)

      {

        myAudio.enabled = false;

        toggle.isOn = false;

      }

      else

      {

        myAudio.enabled = true;

        toggle.isOn = true;

      }

    }

  }

Эти настройки означают:

1. Осуществляется проверка, есть ли в PlayerPrefs кэшированная настройка для кнопки «music». Если там нет никакого значения, то создается несколько ключ-значений для кнопки звука со значением 1. Кроме того, тут происходит включение и выключение переключателя AudioSource. Эти настройки будут использованы при первом запуске игры. Значение 1 используется, потому что вы не можете сохранить какое-то определенное логическое значение (но вы можете использовать 0 как false и 1 как true).
2. Тут идет проверка ключа «music», сохраненного в PlayerPrefs. Если значение установлено на 1, значит на проигрывателе была включена музыка, поэтому активируется режим воспроизведения звуков и соответствующий переключатель. В противоположном случае музыку наоборот выключается, а тумблер переходит в отметку OFF.

Теперь сохраните изменения в вашем скрипте и вернитесь в Unity.

Добавьте скрипт PlayerSettings в GameObject и разверните пользовательский интерфейс GameObject. Далее вам нужно открыть меню GameObject, чтобы увидеть его дочерние элементы. Перетащите объект Music GameObject в поле Toggle сценария PlayerSettings, выберите GameObject Game и перетащите AudioSource в поле MyAudio.

Музыка настроена на работу во время игры (так как в функции «Awake» есть код), но вам все равно нужно добавить еще один код, если игрок меняет настройки во время игры. Для этого снова откройте скрипт PlayerSettings и добавьте следующую функцию:

public void ToggleMusic()

  {

    if (toggle.isOn)

    {

      PlayerPrefs.SetInt ("music", 1);

      myAudio.enabled = true;

    }

    else

    {

      PlayerPrefs.SetInt ("music", 0);

      myAudio.enabled = false;

    }

    PlayerPrefs.Save ();

  }

Эти настройки означают почти то же самое, что и код, который вы написали ранее, за исключением того, что в этом случае есть одно важное отличие. Этот код сначала проверяет состояние переключателя музыки, а затем соответствующим образом обновляет сохраненную настройку. Для того, чтобы этот метод был вызван и, следовательно, чтобы он мог выполнять свою функцию, вам нужно установить метод обратного вызова в Toggle GameObject. Выберите MusicObject Music и перетащите GameObject Game поверх поля объекта в разделе OnValueChanged:

Теперь к раскрывающемуся списку, в котором в данный момент написано «No Function», и выберите PlayerSettings ⇒ ToggleMusic (). Таким образом, когда во время игры пользователь активирует кнопку переключения в меню, появится функция ToggleMusic.

Теперь у вас есть все необходимые настройки, которые нужны чтобы отслеживать опции звуков. Нажмите «Play» и попробуйте изменить настройки музыки, включив или выключив соответствующий переключатель в меню.

Сохранение игры

Согласитесь, возможности и настройка PlayerPrefs не вызывает больших затруднений в использовании. С его помощью вы сможете легко сохранять другие данные, такие как графические настройки проигрывателя или информацию для входа в систему (например, токены Facebook или Twitter), и любые другие параметры конфигурации, которые нужно отслеживать для проигрывателя. Однако PlayerPrefs не предназначен для отслеживания сохранений в игре. Для этого нужно использовать сериализацию.

Первым шагом к созданию файла сохранения игры является создание класса файла сохранения. Создайте новый скрипт с именем Save и удалите пункты MonoBehaviour, Start () и Update ().

Теперь вам необходимо добавить следующие переменные:

public List<int> livingTargetPositions = new List<int>();

public List<int> livingTargetsTypes = new List<int>();




public int hits = 0;

public int shots = 0;

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

Есть еще один очень важный фрагмент кода, который вам также нужно добавить:

 [System.Serializable]

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

Примечание: все эти атрибуты имеют широкий спектр применения и позволяют привязывать данные к классу, методу или определенной переменной. Вы даже можете определить свои собственные атрибуты для использования в вашем коде. Сериализация использует атрибуты [SerializeField] и [System.Serializable], которые определяют, что происходит при сериализации объекта.

Ваш скрипт Save должен выглядеть следующим образом:

using System.Collections;

using System.Collections.Generic;

using UnityEngine;


[System.Serializable]

public class Save

{
  public List<int> livingTargetPositions = new List<int>();

  public List<int> livingTargetsTypes = new List<int>();

  public int hits = 0;

  public int shots = 0;
}

Теперь откройте скрипт Game и добавьте еще один метод:

private Save CreateSaveGameObject()

{
  Save save = new Save();

  int i = 0;

  foreach (GameObject targetGameObject in targets)

  {
    Target target = targetGameObject.GetComponent<Target>();

    if (target.activeRobot != null)

    {

      save.livingTargetPositions.Add(target.position);

      save.livingTargetsTypes.Add((int)target.activeRobot.GetComponent<Robot>().type);

      i++;

    }
  }

  save.hits = hits;

  save.shots = shots;

  return save;
}

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

Кнопка «Save» была подключена к методу SaveGame в скрипте Game, но в SaveGame все еще нет кода. Замените функцию SaveGame следующим кодом:

public void SaveGame()

{
  // 1

  Save save = CreateSaveGameObject();

  // 2
  BinaryFormatter bf = new BinaryFormatter();

  FileStream file = File.Create(Application.persistentDataPath + "/gamesave.save");

  bf.Serialize(file, save);

  file.Close();

  // 3
  hits = 0;

  shots = 0;

  shotsText.text = "Shots: " + shots;

  hitsText.text = "Hits: " + hits;

  ClearRobots();

  ClearBullets();

  Debug.Log("Game Saved");
}

Рассмотрим все по пунктам:

1. Создается экземпляр Save со всеми данными текущего сеанса, сохраненными в нем.
2. Создается BinaryFormatter и FileStream, передав путь для сохранения экземпляру Save. Тут же происходит процесс сериализации данных в байты, с последующим их сохранением на диск и закрытием FileStream. Теперь на вашем компьютере будет файл с именем save. Вы можете использовать любое расширение для имени файла сохранения.
3. Идет сброс настроек игры в состояние по умолчанию.

Чтобы выполнить сохранение процесса, нажмите Escape в любой момент во время игры и используйте кнопку «Save». Обратите внимание, что при этом появляется сообщение о том, что игра была сохранена.

LoadGame в скрипте Game подключен к кнопке Load. Откройте скрипт Game, найдите функцию LoadGame и замените ее следующим значением:

public void LoadGame()

{
  // 1

  if (File.Exists(Application.persistentDataPath + "/gamesave.save"))

  {

    ClearBullets();

    ClearRobots();

    RefreshRobots();

    // 2

    BinaryFormatter bf = new BinaryFormatter();

    FileStream file = File.Open(Application.persistentDataPath + "/gamesave.save", FileMode.Open);

    Save save = (Save)bf.Deserialize(file);

    file.Close();

    // 3

    for (int i = 0; i < save.livingTargetPositions.Count; i++)

    {
      int position = save.livingTargetPositions[i];

      Target target = targets[position].GetComponent<Target>();

      target.ActivateRobot((RobotTypes)save.livingTargetsTypes[i]);

      target.GetComponent<Target>().ResetDeathTimer();
    }

    // 4

    shotsText.text = "Shots: " + save.shots;

    hitsText.text = "Hits: " + save.hits;

    shots = save.shots;

    hits = save.hits;

    Debug.Log("Game Loaded");

    Unpause();
  }

  else

  {
    Debug.Log("No game saved!");
  }
}

Рассмотрим процесс более подробно:

1. Проверяет, существует ли файл сохранения. Если это так, то происходит сброс значений выстрелов и попаданий. В противном случае происходит запись в консоль, что сохраненной игры нет.
2. Подобно тому, что вы делали при сохранении игры, вы снова создадите BinaryFormatter, только на этот раз нужно предоставить поток байтов для чтения вместо записи. Таким образом, вы просто передаете путь к файлу сохранения, чтобы был создан объект Save, а FileStream закрыт.
3. Даже если у вас есть информация о сохранении, вам все равно нужно преобразовать ее в состояние игры. Этот код перебирает сохраненные позиции врагов (для существующих роботов) и добавляет их в эту же позицию. Для простоты таймер сбрасывается, но вы можете исправить это, если хотите. Таким образом роботы не исчезают сразу, а у игрока есть несколько секунд, чтобы сориентироваться в игровом пространстве.
4. Эта команда обновляет пользовательский интерфейс, чтобы установить правильное значение попаданий и выстрелов, с учетом значения, которое было заработано игроком ранее.

Нажмите Play, немного поиграйте в игру и попробуйте сохранится. Нажмите кнопку «Load», и вы увидите, что она загружает врагов таким же образом, какими они были до того, как вы сохранили игру. Кроме того, должны отобразиться счет и количество выстрелов, которые вы сделали.

Сохранение данных с помощью JSON

Есть еще одна хитрость, которую вы можете использовать, когда хотите сохранить данные – это возможности JSON. Вы можете создать локальное JSON-представление сохранения вашей игры, отправить его на сервер, а затем переправить JSON в виде строки на другое устройство и преобразовать его из строки обратно в JSON.

Формат JSON может немного отличаться от того, который вы могли бы использовать с кодом C#, но он довольно прост. Вот один из примеров JSON:

{

  "message":"hi",

  "age":22

  "items":

  [
    "Broadsword",
    "Bow"
  ]
}

Внешние скобки представляют собой родительскую сущность, которой является JSON. Если вы знакомы со структурой данных Dictionary, то JSON чем-то похож на это. Файл JSON представляет собой сопоставление пар ключ-значение. Обратите внимание — приведенный выше пример имеет 3 пары ключ-значение. В JSON ключи всегда являются строками, но значения могут быть объектами (то есть дочерними объектами JSON), массивами, числами или строками. Значение, установленное для ключа «message», равно «hi», значение ключа «age» — это число 22, а значение ключа «items» — это некий массив с двумя строками.

Сам объект JSON представлен типом String. Передав эти данные в виде строки, любой язык может легко воссоздать объект JSON из строки в качестве аргумента конструктора. Это действительно очень удобно и очень просто. У каждого языка есть свой способ создания объекта из этого формата. Начиная с Unity 5.3, существует собственный метод для создания объекта JSON из строки JSON.

В скрипте Game есть метод SaveAsJSON, который подключен к кнопке Save As JSON. Вам нужно заменить следующим кодом:

public void SaveAsJSON()

{
  Save save = CreateSaveGameObject();

  string json = JsonUtility.ToJson(save);

  Debug.Log("Saving as JSON: " + json);
}

Это создает экземпляр Save и строку JSON с использованием метода ToJSON в классе JsonUtility.

Запустите игру и попробуйте уничтожить несколько целей, чтобы набрать очки. Теперь нажмите Escape, чтобы вызвать меню и используйте кнопку Save As JSON, чтобы увидеть созданную вами строку JSON:

Если вы захотите преобразовать этот JSON в экземпляр Save, то вам нужно будет использовать строку:

Save save = JsonUtility.FromJson<Save>(json);

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

Что делать дальше?

Вы можете скачать законченный проект тут.

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

Если вы хотите узнать больше о возможностях Unity, то вам следует обратиться к другим урокам, посвященным этому движку. Если вы уверенно владеете Unity и хотите стать настоящим разработчиком, то советуем вам прочитать книгу Unity Games by Tutorials, с помощью которой вы сможете сделать 4 полноценных игры с нуля.

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

• Чтобы сохранить все текущие изменения сцены и всего проекта, выберите Файл > Сохранить (или Сохранить как).
• Чтобы сохранить изменения всего проекта, но не изменения сцены, выберите Файл > Сохранить проект.

Примечание. Если вы редактируете в режиме Prefab, сохраните через Файл > Сохранить сохраняет изменения только в открытом префабе. Выйдите из Prefab Mode, чтобы сохранить более широкие изменения.

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

Сцена меняется

К изменениям сцены относятся модификации GameObjectsфундаментального объекта в сценах Unity, который может представлять персонажей, реквизит, декорации, камеры, путевые точки и многое другое. Функциональность GameObject определяется прикрепленными к нему компонентами. Подробнее
См. в Словарь в СценаСцена содержит окружение и меню вашей игры. Думайте о каждом уникальном файле сцены как об уникальном уровне. В каждой сцене вы размещаете свое окружение, препятствия и декорации, по сути проектируя и создавая свою игру по частям. Подробнее
См. в Словарь. Например:

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

Изменения в рамках проекта

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

Общие изменения проекта включают:

• Настройки проектаБольшой набор настроек, которые позволяют настраивать физику, звук, работу в сети, графику, ввод и многое другое. ведут себя другие области вашего проекта. Подробнее
  См. в Словарь: Когда вы сохраняете свой проект, Unity сохраняет изменения в настройках проекта в папке Library в этих файлах:

  • Input: InputManager.asset
  • Tags And Layers: TagManager.asset
  • Audio: AudioManager.asset
  • Time: TimeManager.asset
  • Player: ProjectSettings.asset
  • Physics: DynamicsManager.asset
  • Physics 2D: Physics2DSettings.asset
  • Quality: QualitySettings.asset
  • Graphics: GraphicsSettings.asset
  • Network: NetworkManager.asset
  • Editor: EditorUserSettings.asset

• Настройки сборки: Unity сохраняет изменения настроек сборки в папке Библиотека как EditorBuildSettings.asset.

• Измененные ресурсы: когда вы сохраняете настройки для всего проекта, Unity сохраняет все несохраненные ресурсы.

  Примечание. Некоторые типы ресурсов имеют кнопку Применить в Инспекторе. Unity не сохранит их, пока вы не выберете Применить.

• Грязные активы: Unity сохраняет грязные активы, то есть файлы на вашем диске, измененные в программе, но еще не сохраненные. Вы можете использовать пользовательские редакторы и скриптыКусок кода, который позволяет вам создавать свои собственные Компоненты, запускать игровые события, изменять свойства Компонентов с течением времени и реагировать на ввод данных пользователем любым удобным для вас способом. Подробнее
  См. в Словарь, чтобы пометить объект как грязный одним из следующих способов:

  • Используйте класс SerializedObject с SerializedProperties.
  • Используйте класс Undo для записи изменений.
  • Используйте SetDirty.

Автоматическое сохранение

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

• Новые ресурсы: Unity автоматически сохраняет новые ресурсы при их создании, но вам нужно сохранить изменения позже.
• Настройки импорта объектов. Чтобы изменения вступили в силу для большинства объектов, необходимо выбрать Применить в окне Инспектора. Unity сохраняет изменения, когда вы выбираете Применить.
• Запеченные данные. Если в вашем проекте есть данные, для которых установлено значение «Запеченные», Unity сохраняет эту дату после завершения запекания. Это включает в себя:
  • Запеченные данные освещения
  • Запеченные навигационные данные.
  • Запеченное отсечение окклюзииФункция, которая отключает визуализацию объектов, когда они в данный момент не видны камере, поскольку они скрыты ( закрыты) другими объектами. Подробнее
    Посмотреть в данных Словарь
• Изменение порядка выполнения скрипта: после того, как вы нажмете Применить, Unity сохранит эти данные в файле .meta каждого скрипта.

The Player Prefs class in Unity is used to save small amounts of data from your game to disk, which allows you to store and recall single string, integer and float values between gameplay sessions.

This can be extremely useful for saving and loading basic sets of data, such as option settings or simplified game saves.

However, if you’ve tried to use Player Prefs before, particularly to save a game, you may have read or been told not to use them for anything more advanced than basic preference values.

And while there’s some truth to that, there are also many reasons why you would choose to use Player Prefs, so long as you understand how they work.

But don’t worry, in this article I’ll show you how to use Player Prefs in Unity, how they work and how you can use them to save different kinds of data, so that you can decide for yourself how to use them in your own project.

Here’s what you’ll find on this page:

• How to use Player Prefs in Unity
  • Using default values with Player Prefs
  • When to use the Player Prefs Save function
  • How to save options settings using Player Prefs
  • Saving and loading multiple settings with Player Prefs
  • Saving to multiple slots with Player Prefs
  • How to save a boolean using Player Prefs
  • How to save a colour using Player Prefs
• Using Player Prefs for game saves
  • Alternatives to Player Prefs
• Finding Player Prefs in Unity
  • The Player Prefs location
  • How to view a list of all Player Prefs

Let’s get started…

The Player Prefs class in Unity allows you to save basic data between gameplay sessions, such as options settings, that can be saved and reloaded, even after a game has been closed.

It works by storing a string, float or integer value to disk with a key, which is a text string that’s used to store and recall a preference.

For example, to save an integer, simply call the Set Int function of the Player Prefs class and pass in the key you want to use to retrieve it again.

Like this:

public void SaveNumber()
{
    PlayerPrefs.SetInt("myNumber", 100);
}

This will create a new stored preference under that name or, if the key already exists, it will overwrite it, using the new value.

To load the preference again, all you need to do is call Get Int, passing in the same key.

Like this:

public void LoadNumber()
{
    int loadedNumber = PlayerPrefs.GetInt(myNumber);
}

The Set Int function allows you to save and load an integer value however, similar methods are also available to store other data types, such as a float.

Like this:

public void SaveFloat()
{
    PlayerPrefs.SetFloat("myFloat", 0.1234f);
}
public void GetFloat()
{
    float loadedFloat = PlayerPrefs.GetFloat("myFloat");
}

Or a text string, 

Like this:

public void SetString(string value)
{
    PlayerPrefs.SetString("myString", "Hello!");
}
public void GetString()
{
    string loadedString = PlayerPrefs.GetString("myString");
}

The Player Prefs values are stored locally on the device in a preferences file, meaning that they will exist after the game is closed.

This means that, if you want to remove a preference key, you’ll need to manually delete it using a script, even when working in the editor.

To delete a key that you’ve created, simply call the Delete Key function of the Player Prefs class, passing in the key you want to remove.

Like this:

PlayerPrefs.DeleteKey("myString");

This will clear a specific key from Player Prefs file.

Alternatively, to delete all created keys, use the Delete All function.

Like this:

PlayerPrefs.DeleteAll();

Delete All clears everything, so it should be used with caution, especially if you’re saving any kind of progress data using Player Prefs.

However, if you’re using Player Prefs to only store options settings, you might use Delete All to reset everything, returning all custom settings back to their default values.

Using default values with Player Prefs

When loading a preference value, if the key that you enter doesn’t exist, the default value for the data type will be returned instead, which will either be 0 for float and integer values or blank for a string.

However, it’s also possible to specify a custom default value that will be used if the key doesn’t exist.

For example, when getting a float value for a volume setting, if the preference doesn’t exist, instead of using 0, I could use a custom default value of 0.75 instead.

Like this:

float volume = PlayerPrefs.GetFloat("masterVolume", 0.75f);

This can be useful for loading settings where using an automatic default might be a bad thing, such as setting the volume to 0, simply because no player preferences exist.

Alternatively, it’s possible to check that a key exists before trying to load it, using the Has Key method.

Like this:

float volume;
if (PlayerPrefs.HasKey(key))
{
    volume = PlayerPrefs.GetFloat("masterVolume");
}

This can be useful for checking that a key exists before trying to do anything with it.

But… there’s a slight problem with this method.

While the Has Key function will reliably check to see if the key exists in the Player Prefs file, it doesn’t check what type of value is stored.

This means that, if you save a key as a float, for example, using the Set Float function, and then try to find it with its key, the Has Key function will correctly find it, and return true, showing that a key exists under that name.

However, if you then try to retrieve the key, which in this case is a float value, using either the Get Int or Get String functions, no key of that type will be found and a default value will be used instead.

This means that if you accidentally try to retrieve the wrong type of value, you’ll get a default value back as if it doesn’t exist, even if you check using the Has Key function first.

This happens because only one key value can exist for a single preference, but that key can be any one of the supported types, either a string, a float or an integer. This means that it’s possible to overwrite a key with a new data type, causing any other Get function to return nothing.

PlayerPrefs.Save();

Typically, the Player Prefs class is meant for storing options settings and similar preferences.

Which, for single, simple values, can be very straightforward.

However, while many options fit comfortably into a float, string or integer data structure, there are many types that don’t.

Realistically, if you’re using Player Prefs to store options settings, the values you save might include many different types of data.

So how can you manage a whole set of options values, that might include unsupported or complex data types?

How to save options settings with Player Prefs

While the Player Prefs class makes it easy to save and load a single float, string, or integer value, chances are, if you’re using Player Prefs to manage a set of options, you’re probably going to need to save other kinds of value as well.

So how can you manage multiple options with different, unsupported, data types?

Saving and loading multiple settings with Player Prefs

It’s relatively straightforward to save and load multiple settings using Player Prefs.

All you really need to do is group each preference that you want to use in a Save function and a Load function.

Like this:

public float sfxVolume;
public float musicVolume;
public float dialogueVolume;
public void LoadSettings()
{
    sfxVolume = PlayerPrefs.GetFloat("sfxVolume");
    musicVolume = PlayerPrefs.GetFloat("musicVolume");
    dialogueVolume = PlayerPrefs.GetFloat("dialogueVolume");
}
public void SaveSettings()
{
    PlayerPrefs.SetFloat("sfxVolume", sfxVolume);
    PlayerPrefs.SetFloat("musicVolume", musicVolume);
    PlayerPrefs.SetFloat("dialogueVolume", dialogueVolume);
    PlayerPrefs.Save();
}

This will allow you to load and save an entire set of options for a player whenever you need to.

public int slot;
public float sfxVolume;
public float musicVolume;
public float dialogueVolume;
public void LoadSettings()
{
    sfxVolume = PlayerPrefs.GetFloat("sfxVolume" + slot);
    musicVolume = PlayerPrefs.GetFloat("musicVolume" + slot);
    dialogueVolume = PlayerPrefs.GetFloat("dialogueVolume" + slot);
}
public void SaveSettings()
{
    PlayerPrefs.SetFloat("sfxVolume" + slot, sfxVolume);
    PlayerPrefs.SetFloat("musicVolume" + slot, musicVolume);
    PlayerPrefs.SetFloat("dialogueVolume" + slot, dialogueVolume);
}

While it’s relatively straightforward saving supported data types using Player Prefs, not all settings fit so neatly into a string, float or integer.

What if you want to store a boolean value for example?

How to save a boolean using Player Prefs

While there isn’t a built-in method of storing a boolean value using Player Prefs, it’s still possible to save and load booleans by converting their true or false value to an integer.

This works by simply checking the boolean when you save it, passing in a 0 if it’s false, or a 1 if it’s true.

Like this:

bool myBool;
PlayerPrefs.SetInt("myBool", myBool ? 1 : 0);

In this example I’ve used the Ternary Operator, which is a shorthand method of returning one of two values, depending on the condition of another.

Then, when you want to load the boolean value, all you need to do is check to see if the saved integer is equal to 1.

Like this:

myBool = PlayerPrefs.GetInt("myBool") == 1;

If it is, the boolean will be set to true, and if it’s not it’ll be set to false.

So, while this method doesn’t actually store the boolean value, it stores an equivalent integer that can be checked against to set the boolean to true or false accordingly.

This approach of converting a value into a supported type can be used to store all kinds of variables that aren’t natively supported by Player Prefs.

Such as colours for example.

How to save a colour using Player Prefs

It’s possible to store a colour variable using Player Prefs by converting the colour’s values to a readable string, which can be saved and then recalled.

This works by using the Colour Utility class, which can convert a colour to a string that represents its Red, Green and Blue values.

Like this:

Color myColor = Color.red;
string colorString = ColorUtility.ToHtmlStringRGB(myColor);

This converts the value into a Hex colour code, which is a six-character code preceded by a number sign (#), that can be stored as a string.

Like this:

PlayerPrefs.SetString("myColor", ColorUtility.ToHtmlStringRGB(myColor));

To recall the colour, simply use the Colour Utility class to parse the string (remembering to add a leading #), passing the resulting colour out to the variable you’d like to store it in.

Like this:

public Color myColor;
public void LoadSettings()
{
    ColorUtility.TryParseHtmlString("#" + PlayerPrefs.GetString("myColor"), out myColor);
}

The Colour Utility class is convenient for converting colour values to a format that can be used with Player Prefs.

And while not all data types have a function that can be used to convert the value in this way it’s often possible to convert the individual components of a complex variable into a supported format in some way.

Such as Vector 3 values which, by default, are not supported, but can be recreated using the individual floats of the X, Y and Z position values.

Like this:

public GameObject player;
public void LoadPosition()
{
    Vector3 loadedPosition = new Vector3(
            PlayerPrefs.GetFloat("posX"),
            PlayerPrefs.GetFloat("posY"),
            PlayerPrefs.GetFloat("posZ")
        );
    player.transform.position = loadedPosition;
}
public void SavePosition()
{
    Vector3 playerPosition = player.transform.position;
    PlayerPrefs.SetFloat("posX", playerPosition.x);
    PlayerPrefs.SetFloat("posY", playerPosition.y);
    PlayerPrefs.SetFloat("posZ", playerPosition.z);
    PlayerPrefs.Save();
}

This method of deconstructing a variable, storing it as separate values and reconstructing it when it needs to be loaded, can be a useful way of storing complex data using Player Prefs.

Which means that it’s possible to use Player Prefs to store more than just settings.

For example, you could use Player Prefs to create a basic save state, that loads a player’s position, health or number of coins.

So why shouldn’t you?

Is it ok to use Player Prefs for game saves?

And if not, why not?

Using Player Prefs for game saves

While it is possible to store game-related data using the Player Prefs class, it’s not really designed for storing any kind of complex information that’s important to the player’s progress in the game.

So what’s the problem?

Mainly the problem with using Player Prefs for game saves is to do with the technical limitations of the Player Prefs class and how the file is saved to disk.

For example, while it is possible to deconstruct a complex variable into smaller parts that can be saved using Player Prefs, this can quickly become inconvenient and can cause complications when data needs to be grouped.

A high score entry, for example, that could include a combined name and score, might typically be stored in a single class which then might be stored in a list, containing all the high scores. Saving and loading the list object would make it easy to load and sort all of the scores that exist, allowing you to display the top ten.

While recreating the same functionality with Player Prefs is technically possible, it’s not convenient and can take a lot of work. Since one of the main reasons to use Player Prefs is for its simplicity when dealing with basic values, if you’re going to put in the extra work required to save object data in this way, then you may as well use a more suitable option for saving to disk, as it will likely involve a lot of the same processes anyway.

Another reason that Player Prefs may not be suitable for game saves is to do with how they’re stored.

For example, by default, Player Prefs are not encrypted. A player could, technically, change the Player Prefs document to give themself more gold, a higher score, or to modify their progress through the game.

Also, while many platforms store the Player Prefs document in a file, on Windows, Player Prefs is saved to the Registry.

While this isn’t an unusual practice for storing a game’s configuration, you wouldn’t normally expect to find game saves there, as storing large amounts of data in the registry could, potentially, contribute to poor performance or could cause players to lose their game saves if they move a game’s installation folder.

For basic game saves, using smaller amounts of data, it’s not necessarily a huge problem to use Player Prefs to save your game. So long as you can accept that it’s not what the system was designed for, and that, on PC, some users may not expect to find their game save data in the Registry. 

However, while it is technically possible to use Player Prefs as a method of saving complex data, if you need to save larger amounts of information, you may be better off using an alternative option.

Finding Player Prefs in Unity

When working with Player Prefs, because you normally can’t view the preference values that are stored from inside the editor, it can be difficult to know what has been saved and where.

So how can you make working with Player Prefs easier?

One option is to find the stored Player Prefs file on your device.

So where are Player Prefs saved?

The Player Prefs location

The location of the Player Prefs file depends on the device that’s being used and whether or not the preference was set from the editor or a standalone build.

Here’s where you’ll find the Player Prefs file:

Player Prefs location (working in the editor)

• MacOS: /Library/Preferences/unity.Company.Project.plist
• Windows (in the Registry): HKCUSoftwareUnityUnityEditorCompanyProject

Player Prefs location (in the finished game)

• MacOS: ~/Library/Preferences/com.Company.Project.plist
• Windows (in the Registry): HKCUSoftwareCompanyProject 
• Windows Store Apps: %userprofile%AppDataLocalPackagesProductPackageIdLocalStateplayerprefs.dat
• Linux: ~/.config/unity3d/Company/Product
• Android: /data/data/pkg-name/shared_prefs/pkg-name.v2.playerprefs.xml
• iOS: /Library/Preferences/BundleIdentifier.plist

For more information on where and how Unity stores Player Prefs files, see Unity’s official documentation here.

Once you’ve found the Player Prefs file, you’ll be able to manually check it for changes and make sure that your preferences are saving as expected.

It can be much easier, however, to simply view and manage all of your project’s Player Prefs from inside the Unity editor, using an asset.

How to view a list of all Player Prefs

While there isn’t a built-in method of viewing a project’s saved Player Prefs, other than manually finding the file and opening it, it is possible to view and manage all of a project’s stored preferences by using a free asset from the Unity Asset Store.

PlayersPrefs Editor and Utilities is a free, simple to use asset, that shows you a list of all of your Player Prefs.

From there you can delete, add and even encrypt the Player Pref values.

It’s an incredibly useful tool and takes all of the guesswork out of working with Player Prefs.

Совсем недавно мы опубликовали серию уроков (1 часть, 2 часть, 3 часть, 4 часть) по созданию простой игры, используя очень распространенный игровой движок — Unity. В этой статье мы покажем, как организовать систему управления сохраненными играми в Unity. Мы будем писать меню как в Final Fantasy, где игроку предоставляется возможность создать новое уникальное сохранение или же продолжить уже существующее. Итак, к концу урока вы научитесь:

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

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

Первое, что нам нужно сделать, это сериализовать наши данные, которые мы сохраним, а затем в нужное время восстановим. Для этого нам потребуется создать скрипт (в качестве языка программирования будем использовать C#). Давайте назовем его SaveLoad. Этот сценарий будет обрабатывать все, что связано с сохранением и восстановлением данных.

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

Полученный сценарий должен выглядеть вот так:

using UnityEngine;
using System.Collections;
 
public static class SaveLoad {
 
}

Мы хотим добавить немного функциональных возможностей нашему скрипту, а потому давайте пропишем несколько директив:

using System.Collections.Generic; 
using System.Runtime.Serialization.Formatters.Binary; 
using System.IO;

Первая строка позволит нам использовать динамические списки. Вторая — даст нужный функционал операционной системы по сериализации данных. А последняя директива позволяет нам работать с потоками ввода и вывода. Иными словами, она используется для создания и чтения файлов.

Отлично, теперь мы готовы к сериализации данных!

Создание класса, с возможностью сериализации

Игры, похожие на Final Fantasy (то есть многие RPG), предлагают игроку выбрать класс персонажа. Например, рыцарь, разбойник или маг. Создайте новый скрипт, назовите его Game и объявите в нем переменные:

using UnityEngine;
using System.Collections;
 
[System.Serializable]
public class Game { 
 
    public static Game current;
    public Character knight;
    public Character rogue;
    public Character wizard;
 
    public Game () {
        knight = new Character();
        rogue = new Character();
        wizard = new Character();
    }
         
}

Обратите внимание на строчку [System.Serializable], которая говорит движку, что этот скрипт может быть сериализован. Круто, не так ли? Как говорит официальная документация, Unity умеет сериализовать следующие типы данных:

• Все базовые типы (int, string, float, bool и т.д.).
• Некоторые встроенные типы (Vector2, Vector3, Vector4, Quaternion, Matrix4x4, Color, Rect и LayerMask).
• Все классы, унаследованные от UnityEngine.Object (GameObject, Component, MonoBehavior, Texture2D и AnimationClip).
• Перечисляемый тип (Enums).
• Массивы и списки типов данных, перечисленных выше.

Первая переменная, объявленная в нашем классе, — current — является статической ссылкой на экземпляр игры. Когда мы будем сохранять или загружать какие-либо данные, нам потребуется обратиться к «текущей» игре. При использовании статических переменных сделать это особенно просто, без вызова лишних методов. Очень удобно!

Обратите внимание на класс Character. Его еще у нас нет — давайте создадим новый скрипт с таким названием:

using UnityEngine;
using System.Collections;
 
[System.Serializable] 
public class Character {
 
    public string name;
 
    public Character () {
        this.name = "";
    }
}

Ничего странного не заметили? Да, мы действительно создали новый класс, внутри которого есть ровно одна строковая переменная. Мы, конечно же, могли использовать в скрипте Game переменные типа string вместо экземпляров класса Character. Но целью нашей статьи является не то, как сделать лучше, а рассказать, как можно решить нашу проблему.

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

Сохранение игры

Что происходит по нажатию на кнопку «Загрузить игру»? Правильно — показывается список уже сохраненных игры, которые мы можем восстановить. Так давайте создадим список игр и назовем его savedGames:

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.Serialization.Formatters.Binary;
using System.IO;
 
public static class SaveLoad {
 
    public static List<Game> savedGames = new List<Game>();
 
}

А теперь напишем статическую функцию сохранения игры:

public static void Save() {
    savedGames.Add(Game.current);
    BinaryFormatter bf = new BinaryFormatter();
    FileStream file = File.Create (Application.persistentDataPath + "/savedGames.gd");
    bf.Serialize(file, SaveLoad.savedGames);
    file.Close();
}

Разберемся с тем, что же выполняет эта функция. Сначала мы добавляем в ранее созданный список текущую игру. Так как в скрипте Game мы использовали статическую переменную current, то мы можем достаточно просто обратиться к ней: Game.current. После этого нам следует сериализовать список, для чего и создается экземпляр класса BinaryFormatter.

Далее при помощи класса FileStream мы создаем новый файл под названием savedGames.gd в специальной директории, в которой и должны храниться все игровые данные. Для названия файла сохранений будем использовать savedGames, а расширением будет gd (от словосочетания game data).

Примечание автора В качестве расширения файла вы можете использовать все, что угодно. Так, например, в играх The Elder Scrolls используется .esm.

Далее вызывается метод Serialize экземпляра класса BinaryFormatter, который и сохраняет в файл сериализованные данные. И на этом все — файл закрывается. Наша игра сохранена!

Загрузка игры

А здесь все довольно просто. Так как при сохранении игры мы создали файл и записали в него сериализованный список, то сейчас нам придется открыть его и десериализовать имеющиеся в нем данные:

public static void Load() {
    if(File.Exists(Application.persistentDataPath + "/savedGames.gd")) {
        BinaryFormatter bf = new BinaryFormatter();
        FileStream file = File.Open(Application.persistentDataPath + "/savedGames.gd", FileMode.Open);
        SaveLoad.savedGames = (List<Game>)bf.Deserialize(file);
        file.Close();
    }
}

Алгоритм предельно прост. Для начала мы проверяем, существует ли файл сохранений. Если существует, то мы создаем новый экземпляр класса BinaryFormatter, открываем файл savedGames.gd и записываем в список savedGames десериализованные данные, считанные из файла.

Обратите внимание на 5 строчку. Метод Deserialize вернет нам битовую последовательность и, присвоив списку savedGames то, что возвращает функция Deserialize, мы ни к чему хорошему не придем. И поэтому нам следует полученную битовую последовательность преобразовать (привести) к типу List <Game>.

Примечание автора Тип данных, к которому вы приводите десериализованные данные, может быть совершенно разным. Например: Player.lives = (int)bf.Deserialize(file);.

Вывод

Итак, теперь вы знаете, как реализовать систему сохранения и загрузки игровых данных. Наш скрипт готов, и в окончательном виде он выглядит вот так:

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.Serialization.Formatters.Binary;
using System.IO;
 
public static class SaveLoad {
 
    public static List<Game> savedGames = new List<Game>();
             
    //методы загрузки и сохранения статические, поэтому их можно вызвать откуда угодно
    public static void Save() {
        SaveLoad.savedGames.Add(Game.current);
        BinaryFormatter bf = new BinaryFormatter();
        //Application.persistentDataPath это строка; выведите ее в логах и вы увидите расположение файла сохранений
        FileStream file = File.Create (Application.persistentDataPath + "/savedGames.gd");
        bf.Serialize(file, SaveLoad.savedGames);
        file.Close();
    }   
     
    public static void Load() {
        if(File.Exists(Application.persistentDataPath + "/savedGames.gd")) {
            BinaryFormatter bf = new BinaryFormatter();
            FileStream file = File.Open(Application.persistentDataPath + "/savedGames.gd", FileMode.Open);
            SaveLoad.savedGames = (List<Game>)bf.Deserialize(file);
            file.Close();
        }
    }
}

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

_{Перевод статьи «How to Save and Load Your Players’ Progress in Unity»}