コード例 #1
0
ファイル: Program.cs プロジェクト: gavz/ShareX
        private static void CopyFFmpeg(string destination, bool include32bit, bool include64bit)
        {
            if (include32bit)
            {
                if (!File.Exists(FFmpeg32bit))
                {
                    string filename = SetupHelpers.DownloadFile("https://ffmpeg.zeranoe.com/builds/win64/static/ffmpeg-4.2-win64-static.zip");
                    ZipManager.Extract(filename, ".", false, new List <string>()
                    {
                        "ffmpeg.exe"
                    });
                    File.Move("ffmpeg.exe", FFmpeg32bit);
                }

                SetupHelpers.CopyFile(FFmpeg32bit, destination);
            }

            if (include64bit)
            {
                if (!File.Exists(FFmpeg64bit))
                {
                    string filename = SetupHelpers.DownloadFile("https://ffmpeg.zeranoe.com/builds/win32/static/ffmpeg-4.2-win32-static.zip");
                    ZipManager.Extract(filename, ".", false, new List <string>()
                    {
                        "ffmpeg.exe"
                    });
                    File.Move("ffmpeg.exe", FFmpeg64bit);
                }

                SetupHelpers.CopyFile(FFmpeg64bit, destination);
            }
        }
コード例 #2
0
        public static string ExtractPackage(string packageFilePath, string imageEffectsFolderPath)
        {
            if (!string.IsNullOrEmpty(packageFilePath) && File.Exists(packageFilePath) && !string.IsNullOrEmpty(imageEffectsFolderPath))
            {
                string packageName = Path.GetFileNameWithoutExtension(packageFilePath);

                if (!string.IsNullOrEmpty(packageName) && !packageName.StartsWith("."))
                {
                    string destination = Path.Combine(imageEffectsFolderPath, packageName);

                    if (Directory.Exists(destination))
                    {
                        // TODO: Translate
                        if (MessageBox.Show($"Destination folder already exists:\r\n\"{destination}\"\r\n\r\nWould you like to overwrite it?", "ShareX - " +
                                            "Image effect packager", MessageBoxButtons.YesNo, MessageBoxIcon.Warning) == DialogResult.Yes)
                        {
                            Directory.Delete(destination, true);
                        }
                        else
                        {
                            return(null);
                        }
                    }

                    ZipManager.Extract(packageFilePath, destination);

                    return(Path.Combine(destination, ConfigFileName));
                }
            }

            return(null);
        }
コード例 #3
0
ファイル: ImageEffectPackager.cs プロジェクト: McoreD/ShareX
        public static string ExtractPackage(string packageFilePath, string destination)
        {
            string configJson = null;

            if (!string.IsNullOrEmpty(packageFilePath) && File.Exists(packageFilePath) && !string.IsNullOrEmpty(destination))
            {
                ZipManager.Extract(packageFilePath, destination, true, entry =>
                {
                    if (FileHelpers.IsImageFile(entry.Name))
                    {
                        return(true);
                    }

                    if (configJson == null && entry.FullName.Equals(ConfigFileName, StringComparison.OrdinalIgnoreCase))
                    {
                        using (Stream stream = entry.Open())
                            using (StreamReader streamReader = new StreamReader(stream, Encoding.UTF8))
                            {
                                configJson = streamReader.ReadToEnd();
                            }
                    }

                    return(false);
                }, 100_000_000);
            }

            return(configJson);
        }
コード例 #4
0
ファイル: Program.cs プロジェクト: zymITsky/ShareX
        private static void CopyFFmpeg(string destination, bool include32bit, bool include64bit)
        {
            if (include32bit)
            {
                if (!File.Exists(FFmpeg32bit))
                {
                    string filename = SetupHelpers.DownloadFile("https://ffmpeg.zeranoe.com/builds/win32/static/ffmpeg-4.3.1-win32-static.zip");
                    ZipManager.Extract(filename, ".", false, entry => entry.Name.Equals("ffmpeg.exe", StringComparison.OrdinalIgnoreCase), 1_000_000_000);
                    File.Move("ffmpeg.exe", FFmpeg32bit);
                }

                SetupHelpers.CopyFile(FFmpeg32bit, destination);
            }

            if (include64bit)
            {
                if (!File.Exists(FFmpeg64bit))
                {
                    string filename = SetupHelpers.DownloadFile("https://ffmpeg.zeranoe.com/builds/win64/static/ffmpeg-4.3.1-win64-static.zip");
                    ZipManager.Extract(filename, ".", false, entry => entry.Name.Equals("ffmpeg.exe", StringComparison.OrdinalIgnoreCase), 1_000_000_000);
                    File.Move("ffmpeg.exe", FFmpeg64bit);
                }

                SetupHelpers.CopyFile(FFmpeg64bit, destination);
            }
        }
コード例 #5
0
    /// <summary>
    /// Partial extract of a single package, before listing the savegames
    /// Only the quest.ini and translations needs to be extracted to validate quest and get its name
    /// </summary>
    /// <param name="path">path of the file to extract</param>
    public static void ExtractSinglePackagePartial(string path)
    {
        // Extract into temp
        string extractedPath = Path.Combine(ContentData.TempValyriePath, Path.GetFileName(path));

        ZipManager.Extract(extractedPath, path, ZipManager.Extract_mode.ZIPMANAGER_EXTRACT_INI_TXT_PIC);
    }
コード例 #6
0
ファイル: Program.cs プロジェクト: McoreD/ShareX
        private static void CopyFFmpeg(string destination, bool include32bit, bool include64bit)
        {
            if (include32bit)
            {
                if (!File.Exists(FFmpeg32bit))
                {
                    string filePath = SetupHelpers.DownloadFile("https://github.com/ShareX/FFmpeg/releases/download/v4.3.1/ffmpeg-4.3.1-win32.zip");
                    ZipManager.Extract(filePath, ".", false, entry => entry.Name.Equals("ffmpeg.exe", StringComparison.OrdinalIgnoreCase), 100_000_000);
                    File.Move("ffmpeg.exe", FFmpeg32bit);
                }

                SetupHelpers.CopyFile(FFmpeg32bit, destination);
            }

            if (include64bit)
            {
                if (!File.Exists(FFmpeg64bit))
                {
                    string filePath = SetupHelpers.DownloadFile("https://github.com/ShareX/FFmpeg/releases/download/v4.3.1/ffmpeg-4.3.1-win64.zip");
                    ZipManager.Extract(filePath, ".", false, entry => entry.Name.Equals("ffmpeg.exe", StringComparison.OrdinalIgnoreCase), 100_000_000);
                    File.Move("ffmpeg.exe", FFmpeg64bit);
                }

                SetupHelpers.CopyFile(FFmpeg64bit, destination);
            }
        }
コード例 #7
0
    /// <summary>
    /// Fully extract one single package, before starting a quest, and save package filename
    /// </summary>
    /// <param name="path">path of the file to extract</param>
    public static void ExtractSinglePackageFull(string path)
    {
        // Extract into temp
        string tempValkyriePath = ContentData.TempValyriePath;

        mkDir(tempValkyriePath);

        string extractedPath = Path.Combine(tempValkyriePath, Path.GetFileName(path));

        ZipManager.Extract(extractedPath, path, ZipManager.Extract_mode.ZIPMANAGER_EXTRACT_FULL);
    }
コード例 #8
0
    /// <summary>
    /// Partial extract of all package in a directory, to list quests,  and save package filename
    /// </summary>
    /// <param name="path">path of the directory containing .valkyrie package</param>
    public static void ExtractPackages(string path)
    {
        // Find all packages at path
        string[] archives = Directory.GetFiles(path, "*.valkyrie", SearchOption.AllDirectories);

        // Extract all packages
        foreach (string f in archives)
        {
            string extractedPath = Path.Combine(ContentData.TempValyriePath, Path.GetFileName(f));
            ZipManager.Extract(extractedPath, f, ZipManager.Extract_mode.ZIPMANAGER_EXTRACT_INI_TXT_PIC);
        }
    }
コード例 #9
0
        public static bool ExtractFFmpeg(string archivePath, string extractPath)
        {
            try
            {
                ZipManager.Extract(archivePath, extractPath, false, entry => entry.Name.Equals("ffmpeg.exe", StringComparison.OrdinalIgnoreCase), 1_000_000_000);
                return(true);
            }
            catch (Exception e)
            {
                DebugHelper.WriteException(e);
            }

            return(false);
        }
コード例 #10
0
ファイル: FFmpegDownloader.cs プロジェクト: zz110/ShareX
        public static bool ExtractFFmpeg(string archivePath, string extractPath)
        {
            try
            {
                ZipManager.Extract(archivePath, extractPath, false, new List <string>()
                {
                    "ffmpeg.exe"
                });
                return(true);
            }
            catch (Exception e)
            {
                DebugHelper.WriteException(e);
            }

            return(false);
        }
コード例 #11
0
ファイル: ImageEffectPackager.cs プロジェクト: oycq/ShareX
        public static string ExtractPackage(string packageFilePath, string destination)
        {
            if (!string.IsNullOrEmpty(packageFilePath) && File.Exists(packageFilePath) && !string.IsNullOrEmpty(destination))
            {
                string configFilePath = Path.Combine(destination, ConfigFileName);

                if (File.Exists(configFilePath))
                {
                    File.Delete(configFilePath);
                }

                ZipManager.Extract(packageFilePath, destination);

                return(configFilePath);
            }

            return(null);
        }
コード例 #12
0
ファイル: SaveManager.cs プロジェクト: mario2100/valkyrie
        public SaveData(int num = 0)
        {
            Game game = Game.Get();

            if (!File.Exists(SaveFile(num)))
            {
                return;
            }
            try
            {
                if (!Directory.Exists(ContentData.TempValyriePath))
                {
                    Directory.CreateDirectory(ContentData.TempValyriePath);
                }
                string valkyrieLoadPath = Path.Combine(ContentData.TempValyriePath, "Preload");
                if (!Directory.Exists(valkyrieLoadPath))
                {
                    Directory.CreateDirectory(valkyrieLoadPath);
                }

                ZipManager.Extract(valkyrieLoadPath, SaveFile(num), ZipManager.Extract_mode.ZIPMANAGER_EXTRACT_SAVE_INI_PIC);

                image = ContentData.FileToTexture(Path.Combine(valkyrieLoadPath, "image.png"));

                string  data     = File.ReadAllText(Path.Combine(valkyrieLoadPath, "save.ini"));
                IniData saveData = IniRead.ReadFromString(data);

                // when loading a quest, path should always be $TMP/load/quest/$subquest/quest.ini
                // Make sure it is when loading a quest saved for the first time, as in that case it is the original load path
                string questLoadPath     = Path.GetDirectoryName(saveData.Get("Quest", "path"));
                string questOriginalPath = saveData.Get("Quest", "originalpath");

                // loading a quest saved for the first time
                if (questLoadPath.Contains(questOriginalPath))
                {
                    questLoadPath = questLoadPath.Replace(questOriginalPath, ContentData.ValkyrieLoadQuestPath);
                }

                // use preload path rather than load
                questLoadPath = questLoadPath.Replace(ContentData.ValkyrieLoadPath, ContentData.ValkyriePreloadPath);
                QuestData.Quest q = new QuestData.Quest(questLoadPath);
                if (!q.valid)
                {
                    ValkyrieDebug.Log("Warning: Save " + num + " contains unsupported quest version." + Environment.NewLine);
                    return;
                }

                quest_name = saveData.Get("Quest", "questname");

                if (VersionManager.VersionNewer(game.version, saveData.Get("Quest", "valkyrie")))
                {
                    ValkyrieDebug.Log("Warning: Save " + num + " is from a future version." + Environment.NewLine);
                    return;
                }

                if (!VersionManager.VersionNewerOrEqual(minValkyieVersion, saveData.Get("Quest", "valkyrie")))
                {
                    ValkyrieDebug.Log("Warning: Save " + num + " is from an old unsupported version." + Environment.NewLine);
                    return;
                }

                saveTime = DateTime.Parse(saveData.Get("Quest", "time"));

                valid = true;
            }
            catch (Exception e)
            {
                ValkyrieDebug.Log("Warning: Unable to open save file: " + SaveFile(num) + "\nException: " + e.ToString());
            }
        }
コード例 #13
0
ファイル: SaveManager.cs プロジェクト: mario2100/valkyrie
    // Load a saved game, does nothing if file does not exist
    public static void Load(int num = 0)
    {
        Game game = Game.Get();

        try
        {
            if (File.Exists(SaveFile(num)))
            {
                if (!Directory.Exists(ContentData.TempValyriePath))
                {
                    Directory.CreateDirectory(ContentData.TempValyriePath);
                }
                string valkyrieLoadPath = Path.Combine(ContentData.TempValyriePath, "Load");

                if (!Directory.Exists(valkyrieLoadPath))
                {
                    Directory.CreateDirectory(valkyrieLoadPath);
                }

                Directory.Delete(valkyrieLoadPath, true);
                ZipManager.Extract(valkyrieLoadPath, SaveFile(num), ZipManager.Extract_mode.ZIPMANAGER_EXTRACT_FULL);

                string  savefile_content = File.ReadAllText(Path.Combine(valkyrieLoadPath, "save.ini"));
                IniData saveData         = IniRead.ReadFromString(savefile_content);

                // when loading a quest, path should always be $TMP/load/quest/$subquest/quest.ini
                // Make sure it is when loading a quest saved for the first time, as in that case it is the original load path
                string questLoadPath     = Path.GetDirectoryName(saveData.Get("Quest", "path"));
                string questOriginalPath = saveData.Get("Quest", "originalpath");

                // loading a quest saved for the first time
                if (questLoadPath.Contains(questOriginalPath))
                {
                    questLoadPath = questLoadPath.Replace(questOriginalPath, ContentData.ValkyrieLoadQuestPath);
                }

                // Check that quest in save is valid
                QuestData.Quest q = new QuestData.Quest(questLoadPath);
                if (!q.valid)
                {
                    ValkyrieDebug.Log("Error: save contains unsupported quest version." + Environment.NewLine);
                    GameStateManager.MainMenu();
                    return;
                }
                saveData.data["Quest"]["path"] = Path.Combine(questLoadPath, "quest.ini");

                if (VersionManager.VersionNewer(game.version, saveData.Get("Quest", "valkyrie")))
                {
                    ValkyrieDebug.Log("Error: save is from a future version." + Environment.NewLine);
                    GameStateManager.MainMenu();
                    return;
                }

                if (!VersionManager.VersionNewerOrEqual(minValkyieVersion, saveData.Get("Quest", "valkyrie")))
                {
                    ValkyrieDebug.Log("Error: save is from an old unsupported version." + Environment.NewLine);
                    GameStateManager.MainMenu();
                    return;
                }

                Destroyer.Dialog();

                // Load content that the save game uses
                Dictionary <string, string> packs = saveData.Get("Packs");
                foreach (KeyValuePair <string, string> kv in packs)
                {
                    // Support for save games from 1.2 and older
                    if (kv.Key.Equals("FA"))
                    {
                        game.ContentLoader.LoadContentID("FAI");
                        game.ContentLoader.LoadContentID("FAM");
                        game.ContentLoader.LoadContentID("FAT");
                    }
                    if (kv.Key.Equals("CotW"))
                    {
                        game.ContentLoader.LoadContentID("CotWI");
                        game.ContentLoader.LoadContentID("CotWM");
                        game.ContentLoader.LoadContentID("CotWT");
                    }
                    if (kv.Key.Equals("MoM1E"))
                    {
                        game.ContentLoader.LoadContentID("MoM1EI");
                        game.ContentLoader.LoadContentID("MoM1EM");
                        game.ContentLoader.LoadContentID("MoM1ET");
                    }
                    else
                    {
                        game.ContentLoader.LoadContentID(kv.Key);
                    }
                }

                // This loads the game
                new Quest(saveData);

                // Draw things on the screen
                game.heroCanvas.SetupUI();
                game.heroCanvas.UpdateImages();
                game.heroCanvas.UpdateStatus();

                if (game.gameType.DisplayMorale())
                {
                    game.moraleDisplay = new MoraleDisplay();
                }
                if (!game.gameType.DisplayHeroes())
                {
                    game.heroCanvas.Clean();
                }

                // Create the menu button
                new MenuButton();
                new LogButton();
                new SkillButton();
                new InventoryButton();
                game.stageUI = new NextStageButton();
            }
        }
        catch (IOException e)
        {
            ValkyrieDebug.Log("Error: Unable to open save file: " + SaveFile(num) + " " + e.Message);
            Application.Quit();
        }
    }
コード例 #14
0
        private static void ExtractFiles(string zipToExtractPath, DirectoryInfo extractionDestinationPath, ZipExtraction zipExtractionMode)
        {
            var zipFiles = ZipManager.Extract(new MemoryStream(File.ReadAllBytes(zipToExtractPath)));

            foreach (var zipItem in zipFiles.Where(zipItem => zipItem.Data.Length > 0))
            {
                var names = zipItem.Filename.Split('/');
                // Carico l'effettivo nome file
                var fileName        = names.Length > 0 ? names.Last() : names[0];
                var destinationName = Path.Combine(extractionDestinationPath.FullName, fileName);

                // Definisco come gestire il nesting
                switch (zipExtractionMode)
                {
                // Estrazione piatta di tutti gli elementi
                case ZipExtraction.FlatExtraction:
                {
                    // Niente da fare: in fileName ho già il nome e non serve caricare le cartelle
                }
                break;

                case ZipExtraction.FullDirectoryExtraction:
                {
                    // Devo caricare tutte le directory (se presenti)
                    if (names.Length > 1)
                    {
                        var fileInfo = new FileInfo(Path.Combine(extractionDestinationPath.FullName, zipItem.Filename.Replace('/', '\\')));
                        if (fileInfo.Directory != null)
                        {
                            // Creo la directory se non esiste
                            fileInfo.Directory.Create();
                            // Aggiorno il path
                            destinationName = Path.Combine(destinationName, fileInfo.Directory.FullName, fileName);
                        }
                    }
                }
                break;

                case ZipExtraction.FullInternalDirectionExtraction:
                {
                    // Carico tutte le directory meno che la prima
                    // Devo caricare tutte le directory (se presenti)
                    if (names.Length > 2)
                    {
                        var fileInfo = new FileInfo(Path.Combine(extractionDestinationPath.FullName, zipItem.Filename.Substring(zipItem.Filename.IndexOf('/') + 1).Replace('/', '\\')));
                        if (fileInfo.Directory != null)
                        {
                            // Creo la directory se non esiste
                            fileInfo.Directory.Create();
                            // Aggiorno il path
                            destinationName = Path.Combine(destinationName, fileInfo.Directory.FullName, fileName);
                        }
                    }
                }
                break;
                }
                File.WriteAllBytes(destinationName, zipItem.Data);
            }

            // Elimino lo zip di aggiornamento
            File.Delete(zipToExtractPath);
        }