public static ES2Data LoadAll(string path)
{
ES2Settings settings = new ES2Settings(path);
using (ES2Reader reader = ES2Reader.Create(settings))
return(reader.ReadAll());
}
public bool Rename(string oldTag, string newTag)
{
using (ES2Reader reader = ES2Reader.Create(settings))
{
return(reader.RenameTag(oldTag, newTag, this));
}
}
public bool Delete()
{
using (ES2Reader reader = ES2Reader.Create(settings))
{
return(reader.DeleteTags(tagsToDelete, this));
}
}
public static System.Object LoadObject(string identifier, ES2Settings settings)
{
ES2Settings newSettings = settings.Clone(identifier);
using (ES2Reader reader = ES2Reader.Create(newSettings))
return(reader.ReadObject(newSettings.filenameData.tag));
}
// Loads Settings if a config file exists
private void LoadSettings()
{
// If file exists, then load settings
if (ES2.Exists(Application.persistentDataPath + "/" + sConfigFileName))
{
ES2Reader configReader = ES2Reader.Create(Application.persistentDataPath + "/" + sConfigFileName);
LoadConfig(configReader);
configReader.Dispose();
}
else // Otherwise, detect display settings
{
DetectDisplaySettings();
QualitySettings.vSyncCount = 1;
}
if (ES2.Exists(Application.persistentDataPath + "/" + sInputFileName))
{
ES2Reader inputReader = ES2Reader.Create(Application.persistentDataPath + "/" + sInputFileName);
LoadInputMaps(inputReader);
LoadGamepadConfigMaps(inputReader);
inputReader.Dispose();
}
}
public string[] GetTags()
{
using (ES2Reader reader = ES2Reader.Create(data, settings))
{
return(reader.GetTags());
}
}
public static void LoadArray <T>(string identifier, T[] c) where T : class
{
ES2Settings newSettings = new ES2Settings(identifier);
using (ES2Reader reader = ES2Reader.Create(newSettings))
reader.ReadArray <T>(newSettings.filenameData.tag, c);
}
public static Dictionary <TKey, TValue> LoadDictionary <TKey, TValue>(string identifier, ES2Settings settings)
{
ES2Settings newSettings = settings.Clone(identifier);
using (ES2Reader reader = ES2Reader.Create(newSettings))
return(reader.ReadDictionary <TKey, TValue>(newSettings.filenameData.tag));
}
public static byte[] LoadRaw(string identifier, ES2Settings settings)
{
ES2Settings newSettings = settings.Clone(identifier);
using (ES2Reader reader = ES2Reader.Create(newSettings))
return(reader.ReadRaw());
}
/*
* Reads tags from the bytes provided, and writes them to the Writer if they're not marked for deletion.
*/
private bool Delete(byte[] bytes)
{
using (ES2Reader reader = ES2Reader.Create(bytes, settings))
{
return(reader.DeleteTags(tagsToDelete, this));
}
}
public static Stack <T> LoadStack <T>(string identifier, ES2Settings settings)
{
ES2Settings newSettings = settings.Clone(identifier);
using (ES2Reader reader = ES2Reader.Create(newSettings))
return(reader.ReadStack <T>(newSettings.filenameData.tag));
}
public static ES2Data LoadAll(string identifier, ES2Settings settings)
{
ES2Settings newSettings = settings.Clone(identifier);
using (ES2Reader reader = ES2Reader.Create(newSettings))
return(reader.ReadAll());
}
public static void LoadList <T>(string identifier, List <T> c, ES2Settings settings) where T : class
{
ES2Settings newSettings = settings.Clone(identifier);
using (ES2Reader reader = ES2Reader.Create(newSettings))
reader.ReadList <T>(newSettings.filenameData.tag, c);
}
public static string[] GetTags(ES2Settings settings)
{
using (ES2Reader reader = ES2Reader.Create(settings))
{
return(reader.GetTags());
}
}
public static Queue <T> LoadQueue <T>(string identifier)
{
ES2Settings newSettings = new ES2Settings(identifier);
using (ES2Reader reader = ES2Reader.Create(newSettings))
return(reader.ReadQueue <T>(newSettings.filenameData.tag));
}
public Stack <T> LoadStack <T>(string tag)
{
CheckWWWUsage();
CheckDownloadUsage();
using (ES2Reader reader = ES2Reader.Create(data, settings))
return(reader.ReadStack <T>(tag));
}
public Dictionary <TKey, TValue> LoadDictionary <TKey, TValue>(string tag)
{
CheckWWWUsage();
CheckDownloadUsage();
using (ES2Reader reader = ES2Reader.Create(data, settings))
return(reader.ReadDictionary <TKey, TValue>(tag));
}
public void LoadArray <T>(string tag, T[] c) where T : class
{
CheckWWWUsage();
CheckDownloadUsage();
using (ES2Reader reader = ES2Reader.Create(data, settings))
reader.ReadArray <T>(tag, c);
}
public T[,,] Load3DArray <T>(string tag)
{
CheckWWWUsage();
CheckDownloadUsage();
using (ES2Reader reader = ES2Reader.Create(data, settings))
return(reader.Read3DArray <T>(tag));
}
private ES2Reader GetEncryptedReader()
{
ES2Settings encryptedSettings = new ES2Settings();
encryptedSettings.saveLocation = ES2Settings.SaveLocation.Memory;
// Make sure encrypt=false so we don't enter an infinite loop/Stackoverflow situation.
encryptedSettings.encrypt = false;
return(ES2Reader.Create(GetDecryptedBytes(), encryptedSettings));
}
public static void CreateJsonVaultFiles(string path)
{
try
{
path = path + "/VaultFiles";
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
string[] vaultFiles = ES2.GetFiles(string.Empty, "*.txt");
List <SavedGunSerializable> savedGuns = new List <SavedGunSerializable>();
foreach (string name in vaultFiles)
{
try
{
if (name.Contains("DONTREMOVETHISPARTOFFILENAMEV02a"))
{
if (ES2.Exists(name))
{
using (ES2Reader reader = ES2Reader.Create(name))
{
savedGuns.Add(new SavedGunSerializable(reader.Read <SavedGun>("SavedGun")));
}
}
}
}
catch (Exception e)
{
TNHTweakerLogger.LogError("Vault File could not be loaded");
}
}
foreach (SavedGunSerializable savedGun in savedGuns)
{
if (File.Exists(path + "/" + savedGun.FileName + ".json"))
{
File.Delete(path + "/" + savedGun.FileName + ".json");
}
// Create a new file
using (StreamWriter sw = File.CreateText(path + "/" + savedGun.FileName + ".json"))
{
string characterString = JsonConvert.SerializeObject(savedGun, Formatting.Indented, new StringEnumConverter());
sw.WriteLine(characterString);
sw.Close();
}
}
}
catch (Exception ex)
{
TNHTweakerLogger.LogError(ex.ToString());
}
}
/// <summary>
/// Loads the data.
/// </summary>
public void loadData()
{
using (ES2Reader reader = ES2Reader.Create(GameManager.Instance.saveFileName))
{
for (int i = 0; i < allLevelSettings.Length; i++)
{
allLevelSettings[i].loadData(i, reader);
}
}
}
private WorldCreatFlugHelper()
{
PioneerManager.getInstance().setObserver(this);
if (ES2.Exists("BasicData"))
{
ES2Reader reader = ES2Reader.Create("BasicData");
this.worldPasses = reader.ReadList <Int32>("WorldPass");
this.worldIdDefault = reader.Read <Int32>("WorldIdDefault");
}
}
public List <Vector3> GetDungeonData()
{
string loadName = SelectedLoadFile + ".edg";
List <Vector3> tileSpawnPositions = new List <Vector3>();
using (ES2Reader reader = ES2Reader.Create("dungeonSaves/" + loadName))
{
tileSpawnPositions = reader.ReadList <Vector3>("tilePositions");
}
return(tileSpawnPositions);
}
public Dictionary <Transform, int> GetDungeonProps()
{
string loadName = selectedLoadFile + ".edg";
Dictionary <Transform, int> dungeonProps = new Dictionary <Transform, int>();
using (ES2Reader reader = ES2Reader.Create("dungeonSaves/" + loadName))
{
dungeonProps = reader.ReadDictionary <Transform, int>("dungeonProps");
}
return(dungeonProps);
}
/// <summary>
/// Load the collection using EasySave2
/// </summary>
/// <param name="fileName"></param>
public void LoadEasySave2(string fileName, params string[] additionalFields)
{
if (ES2.Exists(fileName) == false)
{
// No data to load yet
Debug.LogWarning("Can't load from file " + fileName + " file does not exist.", gameObject);
return;
}
// Load all the items
if (useReferences)
{
_LoadEasySave2References(fileName);
}
else
{
_LoadEasySave2(fileName);
}
using (ES2Reader reader = ES2Reader.Create(fileName))
{
if (reader.TagExists("additinalFields_" + easySaveCollectionName) == false)
{
return;
}
float[] additional = reader.ReadArray <float>("additinalFields_" + easySaveCollectionName);
for (int i = 0; i < additional.Length; i++)
{
var f = GetType().GetField(additionalFields[i], BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
if (f != null)
{
var t = f.GetValue(this).GetType();
if (t == typeof(int))
{
f.SetValue(this, (int)additional[i]);
}
else if (t == typeof(float))
{
f.SetValue(this, (float)additional[i]);
}
else if (t == typeof(uint))
{
f.SetValue(this, (uint)additional[i]);
}
else
{
Debug.LogWarning("Type not found for " + t.ToString());
}
}
}
}
}
public override void LoadItems(Action <object> callback)
{
if (ES2.Exists(fileName) == false)
{
Debug.Log("Can't load from file " + fileName + " file does not exist.", gameObject);
return;
}
using (ES2Reader reader = ES2Reader.Create(fileName))
{
callback(reader.Read <ItemContainerSerializationModel>(saveName));
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public static IEnumerator LoadFromAssetBundle <T> (string assetbundle, string filename, string tag, load_complete <T> fn)
{
yield return(AssetManager.GetManager().StartCoroutine(AssetManager.GetManager().LoadAsset <TextAsset>(assetbundle, filename, (TextAsset prefab) =>
{
ES2Settings settings = new ES2Settings();
settings.saveLocation = ES2Settings.SaveLocation.Memory;
using (ES2Reader reader = ES2Reader.Create(prefab.bytes, settings))
{
T parm = reader.Read <T>(tag);
fn(parm);
}
})));
}
public static Texture2D LoadImage(string path)
{
if (Application.platform == RuntimePlatform.WebGLPlayer)
{
Debug.LogError("Easy Save 2 Error: You cannot use LoadImage with WebGL");
}
ES2Settings settings = new ES2Settings(path);
if (!settings.IsImageFile)
{
Debug.LogError("ES2.LoadImage can only be used to load JPG and PNG files.\nThe exception thrown is as follows:\n");
}
using (ES2Reader reader = ES2Reader.Create(settings))
return(LoadImage(reader.ReadRaw()));
}
private void _LoadEasySave2References(string fileName, params string[] additionalFields)
{
using (ES2Reader reader = ES2Reader.Create(fileName))
{
// Read data from the file in any order.
InventoryItemReferenceSaveLookup[] data = reader.ReadArray <InventoryItemReferenceSaveLookup>("itemReferenceLookups_" + easySaveCollectionName);
var l = new List <InventoryItemBase>(data.Length);
var cols = Object.FindObjectsOfType <ItemCollectionBase>();
foreach (var item in data)
{
if (item.itemID == -1)
{
l.Add(null);
}
else
{
foreach (var col in cols)
{
if (col.collectionName == item.referenceOfCollection)
{
// Found it
l.Add(col.Find((uint)item.itemID));
}
}
}
}
if (items.Length < l.Count)
{
AddSlots((uint)(l.Count - items.Length));
}
else if (items.Length > l.Count)
{
RemoveSlots((uint)(items.Length - l.Count));
}
SetItems(l.ToArray(), true);
}
}
