Inheritance diagram for GameIO:

Static Public Member Functions
static void	Init ()

static void	ResetTemp ()

static void	ClearTemp ()

static GameIndex	SaveGame ()

static void	SaveGameCopy (string path)

static GameIndex	WriteGame (string root)

static void	MakeBackup (GameIndex index, string suffix="")

static bool	CanLoad (string root)

static Game	LoadGame (string id, string root, bool cloud)

static void	PrepareSteamCloud (string id, string path="")

static bool	TryLoadSteamCloud (string pathSave)

static void	UpdateGameIndex (GameIndex i)

static void	SaveFile (string path, object obj)

static T	LoadFile< T > (string path)

static void	DeleteGame (string id, bool cloud, bool deleteBackup=true)

static List< GameIndex >	GetGameList (string path, bool sortByName=false, bool includeEmptyFolder=false)

static void	DeleteEmptyGameFolders (string path)

static string	GetNewId (string path, string prefix="", int start=1)

Static Public Member Functions inherited from EClass
static int	rndSeed (int a, int seed)

static int	rnd (long a)

static int	rnd (int a)

static int	curve (long _a, int start, int step, int rate=75)

static int	sqrt (int a)

static int	rndHalf (int a)

static float	rndf (float a)

static int	rndSqrt (int a)

static void	Wait (float a, Card c)

static void	Wait (float a, Point p)

static int	Bigger (int a, int b)

static int	Smaller (int a, int b)

Static Public Attributes
static JsonSerializerSettings	jsReadGame

static JsonSerializerSettings	jsWriteGame

static Formatting	formatting = Formatting.Indented

Static Public Attributes inherited from EClass
static Core	core

Properties
static string	pathCurrentSave `[get]`

static string	pathTemp `[get]`

static int	NumBackup `[get]`

static bool	compressSave `[get]`

Properties inherited from EClass
static Game	game `[get]`

static bool	AdvMode `[get]`

static Player	player `[get]`

static Chara	pc `[get]`

static UI	ui `[get]`

static Map	_map `[get]`

static Zone	_zone `[get]`

static FactionBranch	Branch `[get]`

static FactionBranch	BranchOrHomeBranch `[get]`

static Faction	Home `[get]`

static Faction	Wilds `[get]`

static Scene	scene `[get]`

static BaseGameScreen	screen `[get]`

static GameSetting	setting `[get]`

static GameData	gamedata `[get]`

static ColorProfile	Colors `[get]`

static World	world `[get]`

static SourceManager	sources `[get]`

static SourceManager	editorSources `[get]`

static SoundManager	Sound `[get]`

static CoreDebug	debug `[get]`

Detailed Description

Definition at line 10 of file GameIO.cs.

Member Function Documentation

◆ CanLoad()

static bool GameIO.CanLoad ( string root )

inlinestatic

Definition at line 168 of file GameIO.cs.

    {
        GameIndex gameIndex = IO.LoadFile<GameIndex>(root + "/index.txt");
        return EClass.core.version.IsSaveCompatible(gameIndex.version);
    }

References EClass.core, Version.IsSaveCompatible(), GameIndex.version, and BaseCore.version.

Referenced by Game.TryLoad().

◆ ClearTemp()

static void GameIO.ClearTemp ( )

inlinestatic

Definition at line 64 of file GameIO.cs.

    {
        DirectoryInfo directoryInfo = new DirectoryInfo(pathTemp);
        if (directoryInfo.Exists)
        {
            DirectoryInfo[] directories = directoryInfo.GetDirectories();
            for (int i = 0; i < directories.Length; i++)
            {
                directories[i].Delete(recursive: true);
            }
            FileInfo[] files = directoryInfo.GetFiles();
            for (int i = 0; i < files.Length; i++)
            {
                files[i].Delete();
            }
        }
    }

References pathTemp.

Referenced by Game.Load(), and SaveGame().

◆ DeleteEmptyGameFolders()

static void GameIO.DeleteEmptyGameFolders ( string path )

inlinestatic

Definition at line 364 of file GameIO.cs.

    {
        DirectoryInfo[] directories = new DirectoryInfo(path).GetDirectories();
        foreach (DirectoryInfo directoryInfo in directories)
        {
            if (!File.Exists(directoryInfo?.ToString() + "/game.txt"))
            {
                directoryInfo.Delete(recursive: true);
            }
        }
    }

Referenced by Core.OnApplicationQuit().

◆ DeleteGame()

static void GameIO.DeleteGame	(	string	id,
		bool	cloud,
		bool	deleteBackup = `true`
	)

inlinestatic

Definition at line 288 of file GameIO.cs.

    {
        string path = (cloud ? CorePath.RootSaveCloud : CorePath.RootSave) + id;
        if (!Directory.Exists(path))
        {
            return;
        }
        DirectoryInfo directoryInfo = new DirectoryInfo(path);
        if (directoryInfo.Exists)
        {
            directoryInfo.Delete(recursive: true);
        }
        if (deleteBackup)
        {
            directoryInfo = new DirectoryInfo((cloud ? CorePath.PathBackupCloud : CorePath.PathBackup) + id);
            if (directoryInfo.Exists)
            {
                directoryInfo.Delete(recursive: true);
            }
        }
    }

References CorePath.PathBackup, CorePath.PathBackupCloud, and CorePath.RootSave.

Referenced by Scene.OnUpdate().

◆ GetGameList()

static List< GameIndex > GameIO.GetGameList	(	string	path,
		bool	sortByName = `false`,
		bool	includeEmptyFolder = `false`
	)

inlinestatic

Definition at line 310 of file GameIO.cs.

    {
        List<GameIndex> list = new List<GameIndex>();
        DirectoryInfo directoryInfo = new DirectoryInfo(path);
        if (!directoryInfo.Exists)
        {
            return list;
        }
        DirectoryInfo[] directories = directoryInfo.GetDirectories();
        foreach (DirectoryInfo directoryInfo2 in directories)
        {
            if (File.Exists(directoryInfo2?.ToString() + "/index.txt"))
            {
                try
                {
                    GameIndex gameIndex = IO.LoadFile<GameIndex>(directoryInfo2?.ToString() + "/index.txt");
                    gameIndex.id = directoryInfo2.Name;
                    gameIndex.path = directoryInfo2.FullName;
                    list.Add(gameIndex);
                }
                catch (Exception message)
                {
                    Debug.Log(message);
                    goto IL_0097;
                }
                continue;
            }
            goto IL_0097;
            IL_0097:
            if (includeEmptyFolder && Directory.Exists(CorePath.PathBackup + directoryInfo2.Name))
            {
                GameIndex gameIndex2 = new GameIndex();
                gameIndex2.id = directoryInfo2.Name;
                gameIndex2.path = directoryInfo2.FullName;
                gameIndex2.date = (gameIndex2.real = new Date());
                list.Add(gameIndex2);
            }
        }
        if (sortByName)
        {
            list.Sort(delegate(GameIndex a, GameIndex b)
            {
                int.TryParse(a.id, out var result);
                int.TryParse(b.id, out var result2);
                return result2 - result;
            });
        }
        else
        {
            list.Sort((GameIndex a, GameIndex b) => b.real.GetRawReal() - a.real.GetRawReal());
        }
        return list;
    }

References Debug, Date.GetRawReal(), GameIndex.id, CorePath.PathBackup, and GameIndex.real.

Referenced by LayerFeedback.OnInit(), LayerLoadGame.RefreshInfo(), and LayerLoadGame.RefreshList().

◆ GetNewId()

static string GameIO.GetNewId	(	string	path,
		string	prefix = `""`,
		int	start = `1`
	)

inlinestatic

Definition at line 376 of file GameIO.cs.

    {
        string text = "";
        for (int i = start; i < 999999; i++)
        {
            text = prefix + i;
            if (!Directory.Exists(path + text))
            {
                break;
            }
        }
        return text;
    }

Referenced by Game.Create(), and MakeBackup().

◆ Init()

static void GameIO.Init ( )

inlinestatic

Definition at line 42 of file GameIO.cs.

    {
        JsonSerializerSettings jsonSerializerSettings = jsReadGame;
        jsonSerializerSettings.Error = (EventHandler<Newtonsoft.Json.Serialization.ErrorEventArgs>)Delegate.Combine(jsonSerializerSettings.Error, (EventHandler<Newtonsoft.Json.Serialization.ErrorEventArgs>)delegate(object sender, Newtonsoft.Json.Serialization.ErrorEventArgs args)
        {
            if (args.ErrorContext.Error.Message.Contains("UnknownTypePlaceholder"))
            {
                args.ErrorContext.Handled = true;
            }
        });
    }

References jsReadGame.

Referenced by Core.Init().

◆ LoadFile< T >()

static T GameIO.LoadFile< T > ( string path )

inlinestatic

Type Constraints

T

:

new()

Definition at line 283 of file GameIO.cs.

                                                     : new()
    {
        return IO.LoadFile<T>(path, compressSave, jsReadGame);
    }

References compressSave, and jsReadGame.

◆ LoadGame()

static Game GameIO.LoadGame	(	string	id,
		string	root,
		bool	cloud
	)

inlinestatic

Definition at line 174 of file GameIO.cs.

    {
        Game.id = id;
        GameIndex gameIndex = IO.LoadFile<GameIndex>(root + "/index.txt");
        string path = root + "/game.txt";
        foreach (KeyValuePair<string, string> fallbackType in gameIndex.fallbackTypes)
        {
            ModUtil.fallbackTypes[fallbackType.Key] = fallbackType.Value;
        }
        if (cloud)
        {
            gameIndex.cloud = true;
            Debug.Log(TryLoadSteamCloud(root));
        }
        else if (!File.Exists(path))
        {
            Debug.Log(TryLoadSteamCloud(root));
        }
        return JsonConvert.DeserializeObject<Game>(IO.IsCompressed(path) ? IO.Decompress(path) : File.ReadAllText(path), jsReadGame);
    }

References Debug, GameIndex.fallbackTypes, jsReadGame, and TryLoadSteamCloud().

Referenced by Game.Load().

◆ MakeBackup()

static void GameIO.MakeBackup	(	GameIndex	index,
		string	suffix = `""`
	)

inlinestatic

Definition at line 136 of file GameIO.cs.

    {
        Debug.Log("Start backup:" + index.id);
        string id = index.id;
        bool cloud = index.cloud;
        IO.CreateDirectory(cloud ? CorePath.PathBackupCloud : CorePath.PathBackup);
        string text = (cloud ? CorePath.PathBackupCloud : CorePath.PathBackup) + id;
        IO.CreateDirectory(text);
        Debug.Log(text);
        List<DirectoryInfo> dirs = new DirectoryInfo(text).GetDirectories().ToList();
        dirs.ForeachReverse(delegate(DirectoryInfo i)
        {
            if (!int.TryParse(i.Name, out var _))
            {
                dirs.Remove(i);
            }
        });
        dirs.Sort((DirectoryInfo a, DirectoryInfo b) => int.Parse(a.Name) - int.Parse(b.Name));
        int count = dirs.Count;
        Debug.Log("Deleting excess backup:" + dirs.Count + "/" + NumBackup);
        if (count > NumBackup)
        {
            for (int num = 0; num < count - NumBackup; num++)
            {
                IO.DeleteDirectory(dirs[num].FullName);
            }
        }
        Debug.Log("Copying backup:");
        string newId = GetNewId(text + "/", "", (dirs.Count == 0) ? 1 : int.Parse(dirs.LastItem().Name));
        IO.CopyDir((cloud ? CorePath.RootSaveCloud : CorePath.RootSave) + id + "/", text + "/" + newId, (string s) => s == "Temp");
    }

References GameIndex.cloud, Debug, GetNewId(), GameIndex.id, NumBackup, CorePath.PathBackup, CorePath.PathBackupCloud, CorePath.RootSave, and CorePath.RootSaveCloud.

Referenced by Game.Save().

◆ PrepareSteamCloud()

static void GameIO.PrepareSteamCloud	(	string	id,
		string	path = `""`
	)

inlinestatic

Definition at line 195 of file GameIO.cs.

    {
        if (path.IsEmpty())
        {
            path = CorePath.RootSaveCloud + "/" + id;
        }
        Debug.Log("Prepareing Steam Cloud:" + id + ": " + path);
        string text = CorePath.RootSaveCloud + "/cloud.zip";
        string text2 = path + "/cloud.zip";
        try
        {
            if (File.Exists(text))
            {
                File.Delete(text);
            }
            if (File.Exists(text2))
            {
                File.Delete(text2);
            }
            ZipFile.CreateFromDirectory(path, text);
            if (File.Exists(text2))
            {
                File.Delete(text2);
            }
            File.Move(text, text2);
        }
        catch (Exception ex)
        {
            EClass.ui.Say(ex.Message);
        }
    }

References Debug, and EClass.ui.

Referenced by SaveGame().

◆ ResetTemp()

static void GameIO.ResetTemp ( )

inlinestatic

Definition at line 54 of file GameIO.cs.

    {
        DirectoryInfo directoryInfo = new DirectoryInfo(pathTemp);
        if (directoryInfo.Exists)
        {
            directoryInfo.Delete(recursive: true);
        }
        IO.CreateDirectory(pathTemp);
    }

References pathTemp.

Referenced by Game.Create().

◆ SaveFile()

static void GameIO.SaveFile	(	string	path,
		object	obj
	)

inlinestatic

Definition at line 278 of file GameIO.cs.

    {
        IO.SaveFile(path, obj, compressSave, jsWriteGame);
    }

References compressSave, and jsWriteGame.

Referenced by MapSubset.Save(), and Map.Save().

◆ SaveGame()

static GameIndex GameIO.SaveGame ( )

inlinestatic

Definition at line 82 of file GameIO.cs.

    {
        GameIndex gameIndex = WriteGame(pathCurrentSave);
        DirectoryInfo[] directories = new DirectoryInfo(pathCurrentSave).GetDirectories();
        foreach (DirectoryInfo directoryInfo in directories)
        {
            if (int.TryParse(directoryInfo.Name, out var result) && !EClass.game.spatials.map.ContainsKey(result))
            {
                IO.DeleteDirectory(directoryInfo.FullName);
                Debug.Log("Deleting unused map:" + directoryInfo.FullName);
            }
        }
        ClearTemp();
        if (gameIndex.cloud)
        {
            PrepareSteamCloud(gameIndex.id);
        }
        return gameIndex;
    }

References ClearTemp(), Debug, EClass.game, SpatialManager.map, pathCurrentSave, PrepareSteamCloud(), Game.spatials, and WriteGame().

Referenced by Game.Save().

◆ SaveGameCopy()

static void GameIO.SaveGameCopy ( string path )

inlinestatic

Definition at line 102 of file GameIO.cs.

    {
        IO.CopyDir(pathCurrentSave, path, (string s) => s == "Temp");
        IO.DeleteFile(path + "cloud.zip");
        foreach (Zone zone in EClass.game.spatials.Zones)
        {
            if (zone.map != null)
            {
                zone.map.Save(path + zone.uid + "/");
            }
        }
        EClass.game.version = EClass.core.version;
        WriteGame(path);
    }

References EClass.core, EClass.game, Zone.map, pathCurrentSave, Map.Save(), Game.spatials, Spatial.uid, BaseCore.version, WriteGame(), and SpatialManager.Zones.

Referenced by LayerFeedback.ZipSave().

◆ TryLoadSteamCloud()

static bool GameIO.TryLoadSteamCloud ( string pathSave )

inlinestatic

Definition at line 227 of file GameIO.cs.

    {
        Debug.Log("LoadGame using cloud save");
        string text = pathSave + "/cloud.zip";
        string text2 = CorePath.RootSaveCloud + "/cloud.zip";
        bool flag = false;
        try
        {
            if (!File.Exists(text))
            {
                EClass.ui.Say("Steam Cloud save not found:" + text);
                return true;
            }
            if (File.Exists(text2))
            {
                File.Delete(text2);
            }
            File.Move(text, text2);
            IO.DeleteDirectory(pathSave);
            flag = true;
            Directory.CreateDirectory(pathSave);
            ZipFile.ExtractToDirectory(text2, pathSave);
            if (File.Exists(text))
            {
                File.Delete(text);
            }
            File.Move(text2, text);
        }
        catch (Exception ex)
        {
            EClass.ui.Say(ex.Message);
            if (flag)
            {
                Debug.Log("Try restore backup:");
                if (Directory.Exists(pathSave))
                {
                    Directory.Delete(pathSave);
                }
                File.Move(text2, text);
                return true;
            }
            return false;
        }
        return true;
    }

References Debug, and EClass.ui.

Referenced by LoadGame().

◆ UpdateGameIndex()

static void GameIO.UpdateGameIndex ( GameIndex i )

inlinestatic

Definition at line 273 of file GameIO.cs.

    {
        IO.SaveFile(i.path + "/index.txt", i);
    }

References GameIndex.path.

◆ WriteGame()

static GameIndex GameIO.WriteGame ( string root )

inlinestatic

Definition at line 117 of file GameIO.cs.

    {
        string text = JsonConvert.SerializeObject(EClass.core.game, formatting, jsWriteGame);
        string path = root + "game.txt";
        GameIndex gameIndex = new GameIndex().Create(EClass.core.game);
        gameIndex.id = Game.id;
        gameIndex.cloud = EClass.game.isCloud;
        IO.SaveFile(root + "index.txt", gameIndex);
        if (compressSave)
        {
            IO.Compress(path, text);
        }
        else
        {
            File.WriteAllText(path, text);
        }
        return gameIndex;
    }

References compressSave, EClass.core, GameIndex.Create(), formatting, Core.game, EClass.game, Game.id, Game.isCloud, and jsWriteGame.

Referenced by SaveGame(), and SaveGameCopy().

Member Data Documentation

◆ formatting

Formatting GameIO.formatting = Formatting.Indented

static

Definition at line 32 of file GameIO.cs.

Referenced by WriteGame().

◆ jsReadGame

JsonSerializerSettings GameIO.jsReadGame

static

Initial value:

= new JsonSerializerSettings
    {
        NullValueHandling = NullValueHandling.Ignore,
        DefaultValueHandling = DefaultValueHandling.Ignore,
        PreserveReferencesHandling = PreserveReferencesHandling.Objects,
        TypeNameHandling = TypeNameHandling.Auto,
        Error = IO.OnError,
        SerializationBinder = GameSerializationBinder.Instance
    }

Definition at line 12 of file GameIO.cs.

Referenced by Init(), LoadFile< T >(), and LoadGame().

◆ jsWriteGame

JsonSerializerSettings GameIO.jsWriteGame

static

Initial value:

= new JsonSerializerSettings
    {
        NullValueHandling = NullValueHandling.Ignore,
        DefaultValueHandling = DefaultValueHandling.Ignore,
        PreserveReferencesHandling = PreserveReferencesHandling.Objects,
        TypeNameHandling = TypeNameHandling.Auto,
        ContractResolver = ShouldSerializeContractResolver.Instance,
        Error = IO.OnError
    }

Definition at line 22 of file GameIO.cs.

Referenced by SaveFile(), and WriteGame().

Property Documentation

◆ compressSave

bool GameIO.compressSave

staticget

Definition at line 40 of file GameIO.cs.

Referenced by LoadFile< T >(), SaveFile(), and WriteGame().

◆ NumBackup

int GameIO.NumBackup

staticget

Definition at line 38 of file GameIO.cs.

Referenced by MakeBackup().

◆ pathCurrentSave

string GameIO.pathCurrentSave

staticget

Definition at line 34 of file GameIO.cs.

Referenced by Player.EditBackgroundText(), Player.GenerateBackgroundText(), Player.GetBackgroundText(), Game.Save(), SaveGame(), and SaveGameCopy().

◆ pathTemp

string GameIO.pathTemp

staticget

Definition at line 36 of file GameIO.cs.

Referenced by ClearTemp(), and ResetTemp().

The documentation for this class was generated from the following file:

Elin/GameIO.cs

Static Public Member Functions

Static Public Attributes

Properties

Detailed Description

Member Function Documentation

◆ CanLoad()

◆ ClearTemp()

◆ DeleteEmptyGameFolders()

◆ DeleteGame()

◆ GetGameList()

◆ GetNewId()

◆ Init()

◆ LoadFile< T >()

◆ LoadGame()

◆ MakeBackup()

◆ PrepareSteamCloud()

◆ ResetTemp()

◆ SaveFile()

◆ SaveGame()

◆ SaveGameCopy()

◆ TryLoadSteamCloud()

◆ UpdateGameIndex()

◆ WriteGame()

Member Data Documentation

◆ formatting

◆ jsReadGame

◆ jsWriteGame

Property Documentation

◆ compressSave

◆ NumBackup

◆ pathCurrentSave

◆ pathTemp