GameIO Class Reference

Inheritance diagram for GameIO:

Static Public Member Functions
static void	ResetTemp ()
static void	ClearTemp ()
static GameIndex	SaveGame ()
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	rnd (int a)
static int	curve (int a, int start, int step, int rate=75)
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 9 of file GameIO.cs.

Member Function Documentation

CanLoad()

static bool GameIO.CanLoad ( string  root )

inlinestatic

Definition at line 144 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 61 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 340 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 264 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 286 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(), and LayerLoadGame.RefreshList().

GetNewId()

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

inlinestatic

Definition at line 352 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().

LoadFile< T >()

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

inlinestatic

Type Constraints

T

:

new()

Definition at line 259 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 150 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, ModUtil.fallbackTypes, jsReadGame, and TryLoadSteamCloud().

Referenced by Game.Load().

MakeBackup()

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

inlinestatic

Definition at line 112 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 j = 0; j < count - NumBackup; j++)
            {
                IO.DeleteDirectory(dirs[j].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 171 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 51 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 254 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 79 of file GameIO.cs.

    {
        string text = JsonConvert.SerializeObject(EClass.core.game, formatting, jsWriteGame);
        string path = pathCurrentSave + "game.txt";
        GameIndex gameIndex = new GameIndex().Create(EClass.core.game);
        gameIndex.id = Game.id;
        gameIndex.cloud = EClass.game.isCloud;
        IO.SaveFile(pathCurrentSave + "index.txt", gameIndex);
        if (compressSave)
        {
            IO.Compress(path, text);
        }
        else
        {
            File.WriteAllText(path, text);
        }
        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(), compressSave, EClass.core, GameIndex.Create(), Debug, formatting, Core.game, EClass.game, Game.id, Game.isCloud, jsWriteGame, SpatialManager.map, pathCurrentSave, PrepareSteamCloud(), and Game.spatials.

Referenced by Game.Save().

TryLoadSteamCloud()

static bool GameIO.TryLoadSteamCloud ( string  pathSave )

inlinestatic

Definition at line 203 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 249 of file GameIO.cs.

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

References GameIndex.path.

Member Data Documentation

formatting

Formatting GameIO.formatting = Formatting.Indented

static

Definition at line 31 of file GameIO.cs.

Referenced by SaveGame().

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 11 of file GameIO.cs.

Referenced by 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 21 of file GameIO.cs.

Referenced by SaveFile(), and SaveGame().

Property Documentation

compressSave

bool GameIO.compressSave

staticget

Definition at line 39 of file GameIO.cs.

    {
        get
        {
            if (EClass.core.config.compressSave)
            {
                return !EClass.debug.dontCompressSave;
            }
            return false;
        }
    }

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

NumBackup

int GameIO.NumBackup

staticget

Definition at line 37 of file GameIO.cs.

Referenced by MakeBackup().

pathCurrentSave

string GameIO.pathCurrentSave

staticget

Definition at line 33 of file GameIO.cs.

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

pathTemp

string GameIO.pathTemp

staticget

Definition at line 35 of file GameIO.cs.

Referenced by ClearTemp(), and ResetTemp().

---

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

• Elin/GameIO.cs