GameIO Class Reference

Inheritance diagram for GameIO:

Static Public Member Functions
static void	Init ()
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	rndSeed (int a, int seed)
static int	rnd (long a)
static int	rnd (int a)
static int	curve (int _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 147 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 343 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 267 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 289 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 355 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 262 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 153 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 115 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 174 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 257 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.

    {
        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 206 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 252 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 32 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 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 SaveGame().

Property Documentation

compressSave

bool GameIO.compressSave

staticget

Definition at line 40 of file GameIO.cs.

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

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(), and SaveGame().

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