void LoadQuestData()
{
if (File.Exists(QuestDataPath))
{
var bytes = File.ReadAllBytes(QuestDataPath);
QuestData = SerializationUtility.DeserializeValue <QuestData>(bytes, DataFormat);
if (QuestData == null)
{
ResetQuestData();
}
else
{
CurrentQuestChapterIndex = 0;
while (IsValidQuestChapterIndex(CurrentQuestChapterIndex) &&
QuestBook.QuestChapters[CurrentQuestChapterIndex].Quests.All((quest) => QuestData.IsCompleted(quest.ID)))
{
CurrentQuestChapterIndex++;
}
}
}
else
{
ResetQuestData();
}
}
public static void Load(string fileName, string password = null)
{
Dictionary <string, object> entry;
string filePath = GetFilePath(fileName);
if (File.Exists(filePath))
{
List <Object> objectReferences = new List <Object>();
{
byte[] bytes = File.ReadAllBytes(filePath);
if (!string.IsNullOrWhiteSpace(password))
{
bytes = Decrypt(bytes, password);
}
entry = SerializationUtility.DeserializeValue <Dictionary <string, object> >(
bytes,
DataFormat.JSON,
objectReferences);
}
}
else
{
entry = new Dictionary <string, object>();
}
data.Set(fileName, entry);
}
void LoadHighScoresFromFile()
{
var bytes = File.ReadAllBytes(_highScoreFilePath);
_highScoreEntries = SerializationUtility
.DeserializeValue <List <HighScoreEntry> >(bytes, DataFormat.JSON);
}
void ReadDataFromFile()
{
//get data from json
byte[] bytes = File.ReadAllBytes(dataPath);
userContainer = SerializationUtility.DeserializeValue <UserContainer>(bytes, DataFormat.Binary);
Debug.Log("Reading data from file");
}
public void LoadData(string path)
{
byte[] bytes = Resources.Load <TextAsset>(path).bytes;
newData = SerializationUtility.DeserializeValue <Data>(bytes, DataFormat.JSON);
Debug.Log("dd");
// newData = SerializationUtility.DeserializeValue<Data>(bytes, DataFormat.Binary);
}
private void PopulateSavePreview(IEnumerable <FileInfo> files)
{
foreach (FileInfo file in files)
{
DataFormat format = DataFormat.Binary;
var bytes = File.ReadAllBytes(file.FullName);
if (bytes == null)
{
Debug.LogWarning($"Failed reading file: {file.Name}.");
continue;
}
SaveData saveFile = SerializationUtility.DeserializeValue <SaveData>(bytes, format);
if (saveFile == null)
{
Debug.LogWarning($"Failed serializing file: {file.Name}.");
continue;
}
LoadDataPreview save = Instantiate(saveGO).GetComponent <LoadDataPreview>();
save.name = file.Name.Replace(Save.fileExtension, "");
save.Initialize(save.name, saveFile);
save.SetBackAction(() => loadMenu.SetActive(false));
loadPreview.PushLayoutElement(save.GetComponent <LayoutElement>());
}
loadPreview.SnapToIndex(0);
}
public void OnAfterDeserialize()
{
SerializedData val = SerializationUtility.DeserializeValue <SerializedData>(bytes, DataFormat.Binary, _unityReferences);
_delegate = val.Delegate;
_parameterValues = val.ParameterValues;
}
private void LoadCache()
{
var filePath = Path.Combine(SirenixAssetPaths.OdinTempPath, tempCacheFilename).Replace("\\", "/");
FileInfo file = new FileInfo(filePath);
#if SIRENIX_INTERNAL
// This detects if a crash happened during deserialization of the persistent cache; if so it's likely due to the unsafe bug.
// Delete the cache file so that the user has a chance to rebuild the project.
string deserializedCacheFinishedKey = SirenixAssetPaths.OdinTempPath.Replace('/', '.') + ".CacheDeserializationFinished";
if (EditorPrefs.GetBool(deserializedCacheFinishedKey, true) == false)
{
Debug.LogError("Detected failed deserialization of PersistentContextCache. Deleting cache file. Try forcing a rebuild.");
if (file.Exists)
{
file.Delete();
}
}
EditorPrefs.SetBool(deserializedCacheFinishedKey, false);
#endif
try
{
this.approximateSizePerEntry = defaultApproximateSizePerEntry;
if (file.Exists)
{
using (FileStream stream = file.OpenRead())
{
DeserializationContext context = new DeserializationContext();
context.Config.DebugContext.LoggingPolicy = LoggingPolicy.Silent; // Shut up...
context.Config.DebugContext.ErrorHandlingPolicy = ErrorHandlingPolicy.Resilient; // ... and do your job!
this.cache = SerializationUtility.DeserializeValue <IndexedDictionary <IContextKey, GlobalPersistentContext> >(stream, DataFormat.Binary, new List <UnityEngine.Object>(), context);
}
if (this.EntryCount > 0)
{
this.approximateSizePerEntry = (int)(file.Length / this.EntryCount);
}
}
else
{
this.cache.Clear();
}
}
catch (Exception ex)
{
this.cache = new IndexedDictionary <IContextKey, GlobalPersistentContext>();
Debug.LogError("Exception happened when loading Persistent Context from file.");
Debug.LogException(ex);
}
#if SIRENIX_INTERNAL
finally
{
EditorPrefs.SetBool(deserializedCacheFinishedKey, true);
}
#endif
}
public void LoadRobotDataJsonFromPlayerPrefs(string key)
{
string jsonString = PlayerPrefs.GetString(key);
var bytes = System.Text.Encoding.UTF8.GetBytes(jsonString);
this.robotDataEntries = SerializationUtility.DeserializeValue <List <RobotDataEntry> >(bytes, DataFormat.JSON);
}
internal object DropObject(DropEvents dropEvent)
{
this.dropEvent = dropEvent;
this.WillDrop = true;
this.IsBeingClaimed = dropEvent != DropEvents.None && dropEvent != DropEvents.Canceled;
if (this.lastSeenEvent == EventType.Repaint)
{
this.FinalizeDropObject();
}
if (dropEvent == DropEvents.Copied)
{
if (this.Object.GetType().InheritsFrom(typeof(UnityEngine.Object)))
{
return(this.Object);
}
using (var stream = new MemoryStream())
{
List <UnityEngine.Object> unityReferences;
SerializationUtility.SerializeValue(this.Object, stream, DataFormat.Binary, out unityReferences);
stream.Position = 0;
return(SerializationUtility.DeserializeValue <object>(stream, DataFormat.Binary, unityReferences));
}
}
return(this.Object);
}
public static void SerializeDataDemo()
{
string path = Application.dataPath + "/Editor/EditorLearn/Odin/MyData.json";
var originalData = new MyData();
originalData.reference = new MyData();
originalData.reference.reference = originalData;
// Unity should be allowed to handle serialization and deserialization of its own weird objects.
// So if your data-graph contains UnityEngine.Object types, you will need to provide Odin with
// a list of UnityEngine.Object which it will then use as an external reference resolver.
List <UnityEngine.Object> unityObjectReferences = new List <UnityEngine.Object>();
// 序列化
{
var bytes = SerializationUtility.SerializeValue(originalData, DataFormat.JSON, out unityObjectReferences);
File.WriteAllBytes(path, bytes);
// If you want the json string, use UTF8 encoding
// var jsonString = System.Text.Encoding.UTF8.GetString(bytes);
}
// 反序列化
{
var bytes = File.ReadAllBytes(path);
// If you have a string to deserialize, get the bytes using UTF8 encoding
// var bytes = System.Text.Encoding.UTF8.GetBytes(jsonString);
var data = SerializationUtility.DeserializeValue <MyData>(bytes, DataFormat.JSON, unityObjectReferences);
Debug.Log(data.reference.reference == data);
Debug.Log(originalData.reference.reference == originalData);
}
}
public static NodeGraph Copy(this NodeGraph graph)
{
byte[] copyData = SerializationUtility.SerializeValue(graph, DataFormat.Binary);
NodeGraph gcopy = (NodeGraph)SerializationUtility.DeserializeValue <NodeGraph>(copyData, DataFormat.Binary);
return(gcopy);
}
public static List <NodeGroupGraph> GetAll()
{
List <NodeGroupGraph> groupedNodes = new List <NodeGroupGraph>();
DirectoryInfo customNodesDir = new DirectoryInfo(NodeGroupGraph.exportPath);
if (!customNodesDir.Exists)
{
return(null);
}
FileInfo[] files = customNodesDir.GetFiles("*.nt");
foreach (var file in files)
{
string assID = file.Name.Replace(".nt", "");
if (loadedGraphs.ContainsKey(assID))
{
groupedNodes.Add(loadedGraphs[assID]);
}
else
{
byte[] nodeGroupData = File.ReadAllBytes(file.FullName);
NodeGroupGraph po = SerializationUtility.DeserializeValue <NodeGroupGraph>(nodeGroupData, dataFormat);
groupedNodes.Add(po);
loadedGraphs.Add(po.assetID, po);
}
}
return(groupedNodes);
}
private static void LoadMechaConfig(DataFormat dataFormat)
{
MechaConfigDict.Clear();
DirectoryInfo di = new DirectoryInfo(MechaConfigFolder_Build);
if (di.Exists)
{
foreach (FileInfo fi in di.GetFiles("*.config", SearchOption.AllDirectories))
{
byte[] bytes = File.ReadAllBytes(fi.FullName);
MechaConfig config = SerializationUtility.DeserializeValue <MechaConfig>(bytes, dataFormat);
if (MechaConfigDict.ContainsKey(config.MechaConfigName))
{
Debug.LogError($"机甲配置重名:{config.MechaConfigName}");
}
else
{
MechaConfigDict.Add(config.MechaConfigName, config);
}
}
}
else
{
Debug.LogError("机甲配置表不存在");
}
}
public void OnAfterDeserialize()
{
var val = SerializationUtility.DeserializeValue <OdinSerializedData>(this.bytes, DataFormat.Binary, this.unityReferences);
this.Delegate = val.Delegate;
this.ParameterValues = val.ParameterValues;
}
private static void LoadAbilityGroupConfig(DataFormat dataFormat)
{
AbilityGroupConfigDict.Clear();
DirectoryInfo di = new DirectoryInfo(AbilityGroupConfigFolder_Build);
if (di.Exists)
{
foreach (FileInfo fi in di.GetFiles("*.config", SearchOption.AllDirectories))
{
byte[] bytes = File.ReadAllBytes(fi.FullName);
AbilityGroup config = SerializationUtility.DeserializeValue <AbilityGroup>(bytes, dataFormat);
if (AbilityConfigDict.ContainsKey(config.AbilityGroupName))
{
Debug.LogError($"技能组重名:{config.AbilityGroupName}");
}
else
{
foreach (string ac_name in config.AbilityNames)
{
if (AbilityConfigDict.TryGetValue(ac_name, out Ability ability))
{
config.Abilities.Add(ability);
}
}
AbilityGroupConfigDict.Add(config.AbilityGroupName, config);
}
}
}
else
{
Debug.LogError("技能组配置表不存在");
}
}
private static void LoadMechaComponentConfig(DataFormat dataFormat)
{
MechaComponentConfigDict.Clear();
FileInfo fi = new FileInfo(AllMechaComponentConfigPath_Build);
if (fi.Exists)
{
byte[] bytes = File.ReadAllBytes(fi.FullName);
List <MechaComponentConfig> configs = SerializationUtility.DeserializeValue <List <MechaComponentConfig> >(bytes, dataFormat);
foreach (MechaComponentConfig config in configs)
{
if (MechaComponentConfigDict.ContainsKey(config.MechaComponentKey))
{
Debug.LogError($"机甲组件配置重名:{config.MechaComponentKey}");
}
else
{
MechaComponentConfigDict.Add(config.MechaComponentKey, config);
}
}
}
else
{
Debug.LogError("机甲组件配置表不存在");
}
}
/// <summary>
/// Copies or gets the current object in the clipboard.
/// </summary>
public static object Paste()
{
if (IsEmpty())
{
throw new Exception("No object in clipboard. Check CanPaste() before calling Paste().");
}
if (string.IsNullOrEmpty(GUIUtility.systemCopyBuffer) == false)
{
return(GUIUtility.systemCopyBuffer);
}
else if (Clipboard.copyMode == CopyModes.CopyReference)
{
return(Clipboard.obj);
}
else if (Clipboard.copyMode == CopyModes.DeepCopy)
{
using (var stream = new MemoryStream())
{
List <UnityEngine.Object> unityReferences;
SerializationUtility.SerializeValue(obj, stream, DataFormat.Binary, out unityReferences);
stream.Position = 0;
return(SerializationUtility.DeserializeValue <object>(stream, DataFormat.Binary, unityReferences));
}
}
else if (Clipboard.copyMode == CopyModes.ShallowCopy)
{
return(Clipboard.obj.GetType().GetMethod("MemberwiseClone", Flags.AllMembers).Invoke(Clipboard.obj, null));
}
return(null);
}
public void LoadRobotListFromPlayerPrefs()
{
string jsonString = PlayerPrefs.GetString("RobotList");
var bytes = System.Text.Encoding.UTF8.GetBytes(jsonString);
this.robotList = SerializationUtility.DeserializeValue <List <string> >(bytes, DataFormat.JSON);
}
private static bool DeserializeInternal <T>(out T deserializedObject, string filePath)
{
try
{
if (File.Exists(filePath) == false)
{
throw new FileNotFoundException();
}
using (TextReader stream = new StreamReader(filePath, Encoding.UTF8))
{
string json = stream.ReadToEnd();
byte[] bytes = Encoding.UTF8.GetBytes(json);
deserializedObject = SerializationUtility.DeserializeValue <T>(bytes, DataFormat.JSON);
}
return(true);
}
catch (Exception e)
{
Logger.Error($"JsonDeserialization Failed: {e.ToString()}");
deserializedObject = default;
return(false);
}
}
public void LoadState(string filePath) // this'll be called from per scene
{
if (!File.Exists(filePath))
{
return; // No state to load
}
byte[] bytes = File.ReadAllBytes(filePath);
gameState = SerializationUtility.DeserializeValue <PersistentData>(bytes, DataFormat.Binary);
if (m_manager == null)
{
m_manager = GameManager.Instance;
Debug.Log("manager is null");
}
if (gameState == null)
{
Debug.Log("state is null");
}
m_manager.offerPoints = gameState.favors;
m_manager.currentGod = gameState.patronGod;
m_manager.playerStats.health = gameState.health;
m_manager.Amanager.specialAbilityObject = m_manager.abilityDatabase.getAbilityObject(gameState.specialAbility);
//Debug.Log(m_manager.Amanager.specialAbilityObject.AbilityName);
//m_manager.Amanager.AddAbility();
//m_manager.Amanager.UpdateSpecialAbility();
m_manager.UpdateGods();
LoadInventory();
}
/// <summary>
/// Load a binary save from a given path.
/// </summary>
/// <param name="path"></param>
internal static UniversalSave Load(string path, DataFormat dataFormat)
{
if (File.Exists(path))
{
Dictionary <string, object> dictionary = null;
UniversalSave universalSave = null;
using (var fileStream = new FileStream(path, FileMode.Open))
{
dictionary = SerializationUtility.DeserializeValue <Dictionary <string, object> >(SerializationUtility.CreateReader(fileStream, new DeserializationContext(), dataFormat));
}
if (dictionary != null)
{
return(new UniversalSave()
{
variables = dictionary
});
}
using (var fileStream = new FileStream(path, FileMode.Open))
{
universalSave = SerializationUtility.DeserializeValue <UniversalSave>(SerializationUtility.CreateReader(fileStream, new DeserializationContext(), dataFormat));
}
if (universalSave != null)
{
return(universalSave);
}
}
return(null);
}
public void LoadScene(string path)
{
byte[] ojson = File.ReadAllBytes(path);
var newRoot = SerializationUtility.DeserializeValue <Dictionary <string, SceneGameObject> >(ojson, DataFormat.JSON);
mapLoader.LoadMap(newRoot);
}
public override T Deserialize <T>(object input)
{
using (var ctx = Cache <DeserializationContext> .Claim())
{
ctx.Value.Config.SerializationPolicy = SerializationPolicies.Everything;
return(SerializationUtility.DeserializeValue <T>((byte[])input, DataFormat.Binary, ctx.Value));
}
}
private static T Deserialize <T>(byte[] bytes)
{
var data = SerializationUtility.DeserializeValue <T>(bytes, DATA_FORMAT, _deserializationContext);
_deserializationContext.Reset();
_deserializationContext.StringReferenceResolver = _container;
return(data);
}
public static object Deserialize(byte[] bytes)
{
var context = new DeserializationContext()
{
StringReferenceResolver = new ScriptableObjectStringReferenceResolver(),
};
return(SerializationUtility.DeserializeValue <object>(bytes, DataFormat.Nodes, context));
}
public static T FromBytes <T>(byte[] bytes)
{
#if DONT_USE_ODIN_SERIALIZER
var jsonString = Encoding.UTF8.GetString(bytes);
return(JsonUtility.FromJson <T>(jsonString));
#else
return(SerializationUtility.DeserializeValue <T>(bytes, DataFormat.Binary));
#endif
}
public static T Deserialize <T>(byte[] json, List <UnityEngine.Object> objectReferences)
{
if (json == null || json.Length == 0)
{
return(default(T));
}
return(SerializationUtility.DeserializeValue <T>(json, DataFormat.JSON, objectReferences));
}
private static SettingsData LoadSettings()
{
using (var stream = new StreamReader(SETTINGS_FILE_LOCATION, Encoding.UTF8))
{
var json = stream.ReadToEnd();
var bytes = Encoding.UTF8.GetBytes(json);
return(SerializationUtility.DeserializeValue <SettingsData>(bytes, DataFormat.JSON));
}
}
public void LoadState(string path, DataFormat dataFormat, List <UnityEngine.Object> unityObjectReferences)
{
var bytes = File.ReadAllBytes(path);
// If you have a string to deserialize, get the bytes using UTF8 encoding
// var bytes = System.Text.Encoding.UTF8.GetBytes(jsonString);
var data = SerializationUtility.DeserializeValue <ActorBehavior>(bytes, dataFormat, unityObjectReferences);
}
