public ArrangementForm(Arrangement arrangement, IEnumerable<string> toneNames, DLCPackageCreator control)
        {
            InitializeComponent();

            foreach (var val in Enum.GetValues(typeof(InstrumentTuning))) {
                tuningComboBox.Items.Add(val);
            }
            foreach (var val in Enum.GetValues(typeof(ArrangementType)))
            {
                arrangementTypeCombo.Items.Add(val);
            }
            arrangementTypeCombo.SelectedValueChanged += (sender, e) => {
                // Selecting defaults
                ArrangementType selectedType = ((ArrangementType)((ComboBox)sender).SelectedItem);

                switch (selectedType) {
                    case ArrangementType.Bass:
                        arrangementNameCombo.Items.Clear();
                        arrangementNameCombo.Items.Add(ArrangementName.Bass);
                        arrangementNameCombo.SelectedItem = ArrangementName.Bass;
                        break;
                    case ArrangementType.Vocal:
                        arrangementNameCombo.Items.Clear();
                        arrangementNameCombo.Items.Add(ArrangementName.Vocals);
                        arrangementNameCombo.SelectedItem = ArrangementName.Vocals;
                        break;
                    default:
                        arrangementNameCombo.Items.Clear();
                        arrangementNameCombo.Items.Add(ArrangementName.Combo);
                        arrangementNameCombo.Items.Add(ArrangementName.Lead);
                        arrangementNameCombo.Items.Add(ArrangementName.Rhythm);
                        arrangementNameCombo.SelectedItem = arrangement.Name;
                        break;
                }
                // Disabling options that are not meant for Arrangement Types
                arrangementNameCombo.Enabled = selectedType == ArrangementType.Guitar;
                groupBox1.Enabled = selectedType != ArrangementType.Vocal;
                groupBox2.Enabled = selectedType != ArrangementType.Guitar;
                Picked.Visible = selectedType == ArrangementType.Bass;
                tonesCombo.Enabled = selectedType != ArrangementType.Vocal;
                tuningComboBox.Enabled = selectedType != ArrangementType.Vocal;
                Picked.Checked = selectedType == ArrangementType.Bass ? false : true;

                MasterId.Enabled = selectedType != ArrangementType.Vocal;
                PersistentId.Enabled = selectedType != ArrangementType.Vocal;
            };
            foreach (var tone in toneNames)
            {
                tonesCombo.Items.Add(tone);
            }
            scrollSpeedTrackBar.Scroll += (sender, e) =>
            {
                scrollSpeedDisplay.Text = String.Format("Scroll speed: {0:#.0}", Math.Truncate((decimal)scrollSpeedTrackBar.Value) / 10);
            };
            Arrangement = arrangement;
            parentControl = control;
        }
 public ArrangementForm(DLCPackageCreator control, GameVersion gameVersion)
     : this(new Arrangement
     {
         SongFile = new SongFile { File = "" },
         SongXml = new SongXML { File = "" },
         ArrangementType = ArrangementType.Guitar
     }, control, gameVersion)
 {
 }
 public ArrangementForm(IEnumerable<string> toneNames, DLCPackageCreator control)
     : this(new Arrangement
     {
         SongFile = new SongFile { File = "" },
         SongXml = new SongXML { File = "" },
         ArrangementType = ArrangementType.Guitar,
         RelativeDifficulty = 1,
         ScrollSpeed = 20
     }, toneNames, control)
 {
 }
        private static void ConvertPackageRebuilding(string unpackedDir, string targetFileName, Platform sourcePlatform, Platform targetPlatform, string appId)
        {
            var data = DLCPackageData.LoadFromFolder(unpackedDir, targetPlatform, sourcePlatform);

            // Update AppID
            if (!targetPlatform.IsConsole)
            {
                data.AppId = appId;
            }

            // Build
            DLCPackageCreator.Generate(targetFileName, data, new Platform(targetPlatform.platform, GameVersion.RS2014));
        }
        /// <summary>
        /// Repacks DLCPackage Data
        /// </summary>
        /// <param name="srcPath">if provided (optional) sets the Platform to same as source file</param>
        public void WritePackage(string destPath, DLCPackageData packageData, string srcPath = "")
        {
            // if the srcPath does not exist GetPlatform returns 'None'
            // this generates an error condition so need to check platform of srcPath
            Platform platform;

            if (String.IsNullOrEmpty(srcPath))
            {
                platform = destPath.GetPlatform();
            }
            else
            {
                platform = srcPath.GetPlatform();
            }

            DLCPackageCreator.Generate(destPath, packageData, platform);
        }
        static int Main(string[] args)
        {
            var arguments = DefaultArguments();
            var options   = GetOptions(arguments);

            try
            {
                options.Parse(args);
                if (arguments.ShowHelp)
                {
                    options.WriteOptionDescriptions(Console.Out);
                    return(0);
                }

                if (!arguments.Pack && !arguments.Unpack && !arguments.Build)
                {
                    ShowHelpfulError("Must especify a primary command as 'pack', 'unpack', 'build'.");
                    return(1);
                }
                if (arguments.Build && arguments.Pack ||
                    arguments.Build && arguments.Unpack ||
                    arguments.Pack && arguments.Unpack)
                {
                    ShowHelpfulError("The primary command 'build', 'pack' and 'unpack' can't be used at same time.");
                    return(1);
                }
                if (arguments.Pack || arguments.Unpack)
                {
                    if (arguments.Input == null && arguments.Input.Length <= 0)
                    {
                        ShowHelpfulError("Must specify an 'input' file or directory.");
                        return(1);
                    }
                    if (string.IsNullOrEmpty(arguments.Output))
                    {
                        ShowHelpfulError("Must specified an 'output' file or directory.");
                        return(1);
                    }
                    if ((arguments.Platform.platform == GamePlatform.None && arguments.Platform.version != GameVersion.None) ||
                        (arguments.Platform.platform != GamePlatform.None && arguments.Platform.version == GameVersion.None))
                    {
                        ShowHelpfulError("'platform' argument require 'version' and vice-versa to define platform. Use this option only if you have problem with platform auto identifier");
                        return(1);
                    }
                }

                // BUILD PACKAGE FROM TEMPLATE
                if (arguments.Build)
                {
                    if (string.IsNullOrEmpty(arguments.Template))
                    {
                        ShowHelpfulError("Must specify an 'template' argument with path of the Rocksmith DLC template (*.dlc.xml).");
                        return(1);
                    }
                    if (string.IsNullOrEmpty(arguments.Output))
                    {
                        ShowHelpfulError("Must specified an 'output' file.");
                        return(1);
                    }
                    if (arguments.Output.IsDirectory())
                    {
                        ShowHelpfulError("The 'output' argument in 'build' command must be a file.");
                        return(1);
                    }

                    try
                    {
                        Console.WriteLine("Warning: You should load and save XML with 'RocksmithToolkitGUI 2.3.0.0' or above to make sure it is still valid and compatible with this feature!");

                        DLCPackageData info       = null;
                        var            serializer = new DataContractSerializer(typeof(DLCPackageData));
                        using (var stm = new XmlTextReader(arguments.Template))
                        {
                            info = (DLCPackageData)serializer.ReadObject(stm);
                        }

                        var gameVersion = info.GameVersion;
                        FixPaths(info, arguments.Template, gameVersion);

                        if (info.Pc)
                        {
                            DLCPackageCreator.Generate(arguments.Output, info, new Platform(GamePlatform.Pc, gameVersion));
                        }
                        if (gameVersion == GameVersion.RS2014)
                        {
                            if (info.Mac)
                            {
                                DLCPackageCreator.Generate(arguments.Output, info, new Platform(GamePlatform.Mac, gameVersion));
                            }
                        }
                        if (info.XBox360)
                        {
                            DLCPackageCreator.Generate(Path.Combine(Path.GetDirectoryName(arguments.Output), Path.GetFileNameWithoutExtension(arguments.Output)), info, new Platform(GamePlatform.XBox360, gameVersion));
                        }
                        if (info.PS3)
                        {
                            DLCPackageCreator.Generate(Path.Combine(Path.GetDirectoryName(arguments.Output), Path.GetFileNameWithoutExtension(arguments.Output)), info, new Platform(GamePlatform.PS3, gameVersion));
                        }

                        Console.WriteLine("Package was generated.");
                        return(0);
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine(String.Format("{0}\n{1}\n{2}", "Build error!", ex.Message, ex.InnerException));
                        return(1);
                    }
                }

                // PACK A FOLDER TO A PACKAGE
                if (arguments.Pack)
                {
                    if (!arguments.Input[0].IsDirectory())
                    {
                        ShowHelpfulError("The 'input' argument in 'pack' command must be a directory.");
                        return(1);
                    }

                    var srcFiles = arguments.Input;
                    foreach (string srcFileName in srcFiles)
                    {
                        try
                        {
                            if (arguments.Platform.platform != GamePlatform.None && arguments.Platform.version != GameVersion.None)
                            {
                                Packer.Pack(Path.GetFullPath(srcFileName), Path.GetFullPath(arguments.Output), arguments.UpdateSng, arguments.Platform, arguments.UpdateManifest);
                            }
                            else
                            {
                                Packer.Pack(Path.GetFullPath(srcFileName), Path.GetFullPath(arguments.Output), arguments.UpdateSng, updateManifest: arguments.UpdateManifest);
                            }

                            Console.WriteLine("Packing is complete.");
                            return(0);
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine(String.Format("Packing error!\nFile: {0}\n{1}\n{2}", srcFileName, ex.Message, ex.InnerException));
                            return(1);
                        }
                    }
                }

                // UNPACK A PACKAGE FILE
                if (arguments.Unpack)
                {
                    if (!arguments.Output.IsDirectory())
                    {
                        ShowHelpfulError("The 'output' argument in 'unpack' command must be a directory.");
                        return(1);
                    }

                    var srcFiles = new List <string>();

                    foreach (var name in arguments.Input)
                    {
                        if (name.IsDirectory())
                        {
                            srcFiles.AddRange(Directory.EnumerateFiles(Path.GetFullPath(name), "*.psarc", SearchOption.AllDirectories));
                        }
                        if (File.Exists(name))
                        {
                            srcFiles.Add(name);
                        }
                    }

                    foreach (string srcFileName in srcFiles)
                    {
                        Platform platform = Packer.GetPlatform(srcFileName);
                        if (platform.platform == GamePlatform.None)
                        {
                            Console.WriteLine("Error: Platform not found or invalid 'input' file:" + srcFileName);
                            continue;
                        }

                        try
                        {
                            Packer.Unpack(Path.GetFullPath(srcFileName), Path.GetFullPath(arguments.Output), arguments.DecodeOGG, arguments.OverwriteSongXml);
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine(String.Format("Unpacking error!\nFile: {0}\n{1}\n{2}", srcFileName, ex.Message, ex.InnerException));
                            return(1);
                        }
                    }
                    Console.WriteLine("Unpacking is complete.");
                    return(0);
                }
            }
            catch (OptionException ex)
            {
                ShowHelpfulError(ex.Message);
                return(1);
            }

            return(0);
        }
Example #7
0
        private static void CheckAlbumArt(string srcDir, string dlcName)
        {
            // iterate through unpacked cdlc src folder and find artwork
            var ddsFilesPath = Directory.GetFiles(srcDir, "album_*.dds", SearchOption.AllDirectories);

            if (!ddsFilesPath.Any())
            {
                Console.WriteLine(@"Did not find any album artwork in:" + Environment.NewLine + srcDir);
                Console.WriteLine("");
                Console.ReadLine();
            }

            try
            {
                bool   is64 = false, is128 = false, is256 = false;
                string albumArtPath = String.Empty;

                foreach (var ddsFile in ddsFilesPath)
                {
                    if (ddsFile.Contains("_64"))
                    {
                        is64 = true;
                    }
                    if (ddsFile.Contains("_128"))
                    {
                        is128 = true;
                    }
                    if (ddsFile.Contains("_256"))
                    {
                        is256        = true;
                        albumArtPath = ddsFile;
                    }
                }

                // do not update psarc if album artwork if already valid
                if (is64 && is128 && is256)
                {
                    Console.WriteLine(@"Artwork is valid.");
                    Console.WriteLine("");
                    return;
                }

                if (String.IsNullOrEmpty(albumArtPath))
                {
                    albumArtPath = ddsFilesPath[0];
                }

                Console.WriteLine(@"Repairing album artwork using: " + Path.GetFileName(albumArtPath));
                var ddsFiles = new List <DDSConvertedFile>();

                if (!albumArtPath.Contains("_64"))
                {
                    ddsFiles.Add(new DDSConvertedFile()
                    {
                        sizeX = 64, sizeY = 64, sourceFile = albumArtPath, destinationFile = GeneralExtensions.GetTempFileName(".dds")
                    });
                }
                if (!albumArtPath.Contains("_128"))
                {
                    ddsFiles.Add(new DDSConvertedFile()
                    {
                        sizeX = 128, sizeY = 128, sourceFile = albumArtPath, destinationFile = GeneralExtensions.GetTempFileName(".dds")
                    });
                }
                if (!albumArtPath.Contains("_256"))
                {
                    ddsFiles.Add(new DDSConvertedFile()
                    {
                        sizeX = 256, sizeY = 256, sourceFile = albumArtPath, destinationFile = GeneralExtensions.GetTempFileName(".dds")
                    });
                }

                // Convert to correct dds file sizes
                DLCPackageCreator.ToDDS(ddsFiles);

                var albumArtDir    = Path.GetDirectoryName(albumArtPath);
                var albumArtName   = String.Format("album_{0}", dlcName.ToLower().Replace("_", "").GetValidFileName());
                var ddsPartialPath = Path.Combine(albumArtDir, albumArtName);

                foreach (var dds in ddsFiles)
                {
                    var destAlbumArtPath = String.Format("{0}_{1}.dds", ddsPartialPath, dds.sizeX);
                    if (!File.Exists(dds.destinationFile))
                    {
                        Console.WriteLine(@"Could not repair: " + destAlbumArtPath);
                    }

                    File.Copy(dds.destinationFile, destAlbumArtPath);
                    // delete temp artwork file
                    File.Delete(dds.destinationFile);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("Exception: " + ex.Message);
                Console.ReadLine();
            }
        }
Example #8
0
        static int Main(string[] args)
        {
            Console.WindowWidth     = 85;
            Console.BackgroundColor = ConsoleColor.Black;
            Console.ForegroundColor = ConsoleColor.Green;

#if (DEBUG)
            // give the progie some dumby directory to work on for testing
            // args = new string[] { "--input=D:\\Temp\\Test", "--output=D:\\Temp" }; //, "platform=Pc", "version=RS2014" };
            args = new string[] { "D:\\Temp\\Test" };
#endif

            var      arguments = DefaultArguments();
            var      options   = GetOptions(arguments);
            string[] srcDirs   = null;
            options.Parse(args);

            try
            {
                // drag/drop a directory onto executable application
                if (arguments.Input == null && args.GetLength(0) != 0)
                {
                    try
                    {
                        if (args[0].IsDirectory())
                        {
                            srcDirs = args;
                            if (srcDirs.Length == 1)
                            {
                                srcDirs          = Directory.GetDirectories(srcDirs[0]);
                                arguments.Output = Path.GetDirectoryName(srcDirs[0]);
                            }
                            else
                            {
                                arguments.Output = Path.GetDirectoryName(args[0]);
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        ShowHelpfulError(ex.Message + "  Check that RootFolder structure has SubFolder(s).");
                        return(1); // failure
                    }
                }
                else // command line error checking
                {
                    if (arguments.ShowHelp || args.GetLength(0) == 0)
                    {
                        options.WriteOptionDescriptions(Console.Out);
                        Console.ReadLine();
                        return(-1); // neither success or failure
                    }

                    if (!arguments.Package)
                    {
                        ShowHelpfulError("Must specify the primary command as 'package'");
                        return(1);
                    }

                    if (arguments.Package)
                    {
                        if ((arguments.Input == null && arguments.Input.Length <= 0) || !arguments.Input[0].IsDirectory())
                        {
                            ShowHelpfulError("Must specify and 'input' directory.");
                            return(1);
                        }

                        if (string.IsNullOrEmpty(arguments.Output))
                        {
                            ShowHelpfulError("Must specify an 'output' directory.");
                            return(1);
                        }
                    }

                    if ((arguments.Platform.platform == GamePlatform.None && arguments.Platform.version != GameVersion.None) || (arguments.Platform.platform != GamePlatform.None && arguments.Platform.version == GameVersion.None))
                    {
                        ShowHelpfulError("'platform' argument requires 'version' and vice-versa to define platform.\r\nUse this option only if you have problem with platform auto identifier");
                        return(1);
                    }

                    srcDirs = arguments.Input;
                }

                Console.WriteLine(@"Initializing Package Creator CLI ...");
                Console.WriteLine("");

                var songCount = srcDirs.Length;
                for (int i = 0; i < songCount; i++)
                {
                    Console.WriteLine(@"Parsing Input Directory (" + (i + 1) + @"/" + songCount + @") for CDLC Package Data: " + Path.GetFileName(srcDirs[i]));

                    try
                    {
                        // get package data
                        DLCPackageData packageData = DLCPackageData.LoadFromFolder(srcDirs[i], arguments.Platform, arguments.Platform, false);
                        packageData.AppId = arguments.AppId;
                        packageData.ToolkitInfo.PackageVersion = arguments.Revision;
                        packageData.Name          = Path.GetFileName(srcDirs[i]).GetValidFileName();
                        packageData.Volume        = packageData.Volume == 0 ? Convert.ToInt16(arguments.Decibels) : packageData.Volume;
                        packageData.PreviewVolume = packageData.PreviewVolume == 0 ? Convert.ToInt16(arguments.Decibels) : packageData.PreviewVolume;

                        // check Album Artwork
                        if (arguments.Platform.version == GameVersion.RS2014)
                        {
                            CheckAlbumArt(srcDirs[i], packageData.Name);
                        }

                        // generate CDLC file name
                        var artist = packageData.SongInfo.ArtistSort;
                        var title  = packageData.SongInfo.SongDisplayNameSort;
                        // var destDir = Path.Combine(arguments.Output, Path.GetFileName(srcDirs[i]).GetValidName());
                        var fileName     = StringExtensions.GetValidShortFileName(artist, title, arguments.Revision.Replace(".", "_"), ConfigRepository.Instance().GetBoolean("creator_useacronyms"));
                        var destPath     = Path.Combine(arguments.Output, fileName);
                        var fullFileName = String.Format("{0}{1}.psarc", fileName, DLCPackageCreator.GetPathName(arguments.Platform)[2]);
                        Console.WriteLine(@"Packing: " + Path.GetFileName(fullFileName));
                        Console.WriteLine("");
                        // pack the data
                        DLCPackageCreator.Generate(destPath, packageData, new Platform(arguments.Platform.platform, arguments.Platform.version));
                        packageData.CleanCache();
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine("");
                        Console.WriteLine(String.Format("Packaging error!\nDirectory: {0}\n{1}\n{2}", srcDirs[i], ex.Message, ex.InnerException));
                        Console.ReadLine();
                    }
                }

                Console.WriteLine(@"All Finished");
                Console.WriteLine(@"Press any key to continue ...");
                Console.ReadLine();
                return(0); // success
            }
            catch (Exception ex)
            {
                ShowHelpfulError(ex.Message);
                return(1); // failure
            }
        }
Example #9
0
        public static string DoLikeSongPack(string srcPath, string appId = "248750")
        {
            // create SongPack directory structure
            var dlcName              = Path.GetFileName(srcPath).ToLower();
            var songPackDir          = Path.Combine(Path.GetTempPath(), String.Format("{0}_songpack_p_Pc", dlcName));
            var audioWindowDir       = Path.Combine(songPackDir, "audio", "windows");
            var flatmodelsRsDir      = Path.Combine(songPackDir, "flatmodels", "rs");
            var gamexblocksNsongsDir = Path.Combine(songPackDir, "gamexblocks", "nsongs");
            var gfxassetsAlbumArtDir = Path.Combine(songPackDir, "gfxassets", "album_art");
            var manifestSongsDir     = Path.Combine(songPackDir, "manifests", String.Format("songs_dlc_{0}", dlcName));
            var songsArrDir          = Path.Combine(songPackDir, "songs", "arr");
            var binGenericDir        = Path.Combine(songPackDir, "songs", "bin", "generic");

            if (Directory.Exists(songPackDir))
            {
                IOExtension.DeleteDirectory(songPackDir);
            }

            Directory.CreateDirectory(songPackDir);
            Directory.CreateDirectory(audioWindowDir);
            Directory.CreateDirectory(flatmodelsRsDir);
            Directory.CreateDirectory(gamexblocksNsongsDir);
            Directory.CreateDirectory(gfxassetsAlbumArtDir);
            Directory.CreateDirectory(manifestSongsDir);
            Directory.CreateDirectory(songsArrDir);
            Directory.CreateDirectory(binGenericDir);

            // populate SongPack temporary directory
            var audioWemFiles = Directory.EnumerateFiles(srcPath, "*.wem", SearchOption.AllDirectories).ToArray();

            foreach (var wem in audioWemFiles)
            {
                File.Copy(wem, Path.Combine(audioWindowDir, Path.GetFileName(wem)));
            }

            var audioBnkFiles = Directory.EnumerateFiles(srcPath, "*.bnk", SearchOption.AllDirectories).ToArray();

            foreach (var bnk in audioBnkFiles)
            {
                File.Copy(bnk, Path.Combine(audioWindowDir, Path.GetFileName(bnk)));
            }

            var xblockFiles = Directory.EnumerateFiles(srcPath, "*.xblock", SearchOption.AllDirectories).ToArray();

            foreach (var xblock in xblockFiles)
            {
                File.Copy(xblock, Path.Combine(gamexblocksNsongsDir, Path.GetFileName(xblock)));
            }

            var albumArtFiles = Directory.EnumerateFiles(srcPath, "*.dds", SearchOption.AllDirectories).ToArray();

            foreach (var albumArt in albumArtFiles)
            {
                File.Copy(albumArt, Path.Combine(gfxassetsAlbumArtDir, Path.GetFileName(albumArt)));
            }

            var jsonFiles = Directory.EnumerateFiles(srcPath, "*.json", SearchOption.AllDirectories).ToArray();

            foreach (var json in jsonFiles)
            {
                File.Copy(json, Path.Combine(manifestSongsDir, Path.GetFileName(json)));
            }

            var hsanFiles = Directory.EnumerateFiles(srcPath, "*.hsan", SearchOption.AllDirectories).ToArray();

            foreach (var hsan in hsanFiles)
            {
                File.Copy(hsan, Path.Combine(manifestSongsDir, Path.GetFileName(hsan)));
            }

            var sngFiles = Directory.EnumerateFiles(srcPath, "*.sng", SearchOption.AllDirectories).ToArray();

            foreach (var sng in sngFiles)
            {
                File.Copy(sng, Path.Combine(binGenericDir, Path.GetFileName(sng)));
            }

            // declare variables one time for use in DDC generation
            DDCSettings.Instance.LoadConfigXml();
            var phraseLen = DDCSettings.Instance.PhraseLen;
            // removeSus may be depricated in latest DDC but left here for comptiblity
            var removeSus = DDCSettings.Instance.RemoveSus;
            var rampPath  = DDCSettings.Instance.RampPath;
            var cfgPath   = DDCSettings.Instance.CfgPath;

            // generate SongPack comment
            var spComment = "(Remastered by SongPack Maker)";
            var addDD     = false;

            if (ConfigRepository.Instance().GetBoolean("ddc_autogen"))
            {
                addDD      = true;
                spComment += " " + "(DDC by SongPack Maker)";
            }

            var xmlFiles = Directory.EnumerateFiles(srcPath, "*.xml", SearchOption.AllDirectories).ToArray();

            foreach (var xml in xmlFiles)
            {
                // completely skip dlc.xml template files
                if (xml.EndsWith("_RS2014.dlc.xml"))
                {
                    continue;
                }

                var xmlSongPack = Path.Combine(songsArrDir, Path.GetFileName(xml));
                File.Copy(xml, xmlSongPack);

                // skip vocal and showlight xml files
                if (xml.EndsWith("_vocals.xml") || xml.EndsWith("_showlights.xml"))
                {
                    continue;
                }

                // add DDC to xml arrangement
                if (addDD)
                {
                    // check if arrangment has pre existing DD and do not overwrite
                    var songXml = Song2014.LoadFromFile(xml);
                    var mf      = new ManifestFunctions(GameVersion.RS2014);
                    if (mf.GetMaxDifficulty(songXml) == 0)
                    {
                        var consoleOutput = String.Empty;
                        // apply DD to xml arrangments... 0 = Ends normally with no error
                        var result = DDCreator.ApplyDD(xmlSongPack, phraseLen, removeSus, rampPath, cfgPath, out consoleOutput, true);
                        if (result == 1)
                        {
                            Debug.WriteLine(String.Format("Arrangement file '{0}' => {1}", Path.GetFileNameWithoutExtension(xml), "DDC ended with system error " + consoleOutput));
                        }
                        else if (result == 2)
                        {
                            Debug.WriteLine(String.Format("Arrangement file '{0}' => {1}", Path.GetFileNameWithoutExtension(xml), "DDC ended with application error " + consoleOutput));
                        }
                    }
                }
            }

            // generate new Aggregate Graph
            var aggGraphPack = new AggregateGraph2014();

            aggGraphPack.JsonDB        = new List <GraphItem>();
            aggGraphPack.HsonDB        = new List <GraphItem>(); // used for consoles ONLY
            aggGraphPack.HsanDB        = new GraphItem();
            aggGraphPack.MusicgameSong = new List <GraphItemLLID>();
            aggGraphPack.SongXml       = new List <GraphItemLLID>();
            aggGraphPack.ShowlightXml  = new List <GraphItemLLID>();
            aggGraphPack.ImageArt      = new List <GraphItemLLID>();
            aggGraphPack.Soundbank     = new List <GraphItemLLID>();
            aggGraphPack.GameXblock    = new List <GraphItem>();

            // fix aggregate graph entries, reusing existing Persistent ID
            var currentPlatform     = new Platform(GamePlatform.Pc, GameVersion.RS2014);
            var aggregateGraphFiles = Directory.EnumerateFiles(srcPath, "*.nt", SearchOption.AllDirectories).ToArray();

            foreach (var aggGraph in aggregateGraphFiles)
            {
                var agg = LoadFromFile(aggGraph);

                foreach (var json in agg.JsonDB)
                {
                    json.Canonical        = String.Format(CANONICAL_MANIFEST_PC, dlcName);
                    json.RelPathDirectory = json.Canonical;
                    json.Tag = new List <string>();
                    json.Tag.Add(TagValue.Database.GetDescription());
                    json.Tag.Add(TagValue.JsonDB.GetDescription());
                    json.UUID        = IdGenerator.Guid();
                    json.RelPathFile = String.Format("{0}.json", json.Name);
                }

                aggGraphPack.JsonDB.AddRange(agg.JsonDB);
                aggGraphPack.MusicgameSong.AddRange(agg.MusicgameSong);
                aggGraphPack.SongXml.AddRange(agg.SongXml);
                aggGraphPack.ShowlightXml.AddRange(agg.ShowlightXml);
                aggGraphPack.ImageArt.AddRange(agg.ImageArt);
                aggGraphPack.Soundbank.AddRange(agg.Soundbank);

                aggGraphPack.GameXblock.AddRange(agg.GameXblock);
            }

            // create a single hsanDB entry
            aggGraphPack.HsanDB.Name             = String.Format("songs_dlc_{0}", dlcName);
            aggGraphPack.HsanDB.Canonical        = String.Format(CANONICAL_MANIFEST_PC, dlcName);
            aggGraphPack.HsanDB.RelPathDirectory = aggGraphPack.HsanDB.Canonical;
            aggGraphPack.HsanDB.Tag = new List <string>();
            aggGraphPack.HsanDB.Tag.Add(TagValue.Database.GetDescription());
            aggGraphPack.HsanDB.Tag.Add(TagValue.HsanDB.GetDescription());
            aggGraphPack.HsanDB.UUID        = IdGenerator.Guid();
            aggGraphPack.HsanDB.RelPathFile = String.Format("{0}.hsan", aggGraphPack.HsanDB.Name);

            var aggregateGraphFileName = Path.Combine(songPackDir, String.Format("{0}_aggregategraph.nt", dlcName));

            using (var fs = new FileStream(aggregateGraphFileName, FileMode.Create))
                using (var ms = new MemoryStream())
                {
                    aggGraphPack.Serialize(ms);
                    ms.Flush();
                    ms.Seek(0, SeekOrigin.Begin);
                    ms.CopyTo(fs);
                }

            MergeHsanFiles(songPackDir, dlcName, manifestSongsDir);

            var appIdFile = Path.Combine(songPackDir, "appid.appid");

            File.WriteAllText(appIdFile, appId);

            var toolkitVersionFile = Path.Combine(songPackDir, "toolkit.version");

            using (var fs = new FileStream(toolkitVersionFile, FileMode.Create))
                using (var ms = new MemoryStream())
                {
                    DLCPackageCreator.GenerateToolkitVersion(ms, packageVersion: "SongPack Maker v1.2", packageComment: spComment);
                    ms.Flush();
                    ms.Seek(0, SeekOrigin.Begin);
                    ms.CopyTo(fs);
                }

            var rootFlatFile = Path.Combine(flatmodelsRsDir, "rsenumerable_root.flat");

            using (var fs = new FileStream(rootFlatFile, FileMode.Create))
                using (var ms = new MemoryStream(Resources.rsenumerable_root))
                {
                    ms.Seek(0, SeekOrigin.Begin);
                    ms.CopyTo(fs);
                }

            var songFlatFile = Path.Combine(flatmodelsRsDir, "rsenumerable_song.flat");

            using (var fs = new FileStream(songFlatFile, FileMode.Create))
                using (var ms = new MemoryStream(Resources.rsenumerable_song))
                {
                    ms.Seek(0, SeekOrigin.Begin);
                    ms.CopyTo(fs);
                }

            return(songPackDir);
        }
        static int Main(string[] args)
        {
            try
            {
                Console.SetWindowSize(85, 40); // to prevent ioexceptions
                Console.BackgroundColor = ConsoleColor.Black;
                Console.ForegroundColor = ConsoleColor.Green;
            }
            catch { /* DO NOTHING */ }

#if (DEBUG)
            // give the progie some dumby data to work with
            args = new string[]
            {
                "-u",
                "-x",
                "-d",
                "-input=D:\\Temp\\PeppaPig_p.psarc",
                "-output=D:\\Temp",
                "-v=RS2014",
                "-c",
                "-f=Pc"
            };

            // args = new string[] {"-?"};
            Console.WriteLine("Running in Debug Mode ... help is not available");
#endif

            var arguments = DefaultArguments();
            var options   = GetOptions(arguments);

            try
            {
                options.Parse(args);
                if (arguments.ShowHelp)
                {
                    options.WriteOptionDescriptions(Console.Out);
                    Console.WriteLine("");
                    Console.WriteLine("Press any key to close window ...");
                    Console.ReadLine();
                    return(0);
                }

                if (!arguments.Pack && !arguments.Unpack && !arguments.Build)
                {
                    ShowHelpfulError("Must especify a primary command as 'pack', 'unpack', 'build'.");
                    return(1);
                }
                if (arguments.Build && arguments.Pack ||
                    arguments.Build && arguments.Unpack ||
                    arguments.Pack && arguments.Unpack)
                {
                    ShowHelpfulError("The primary command 'build', 'pack' and 'unpack' can't be used at same time.");
                    return(1);
                }
                if (arguments.Pack || arguments.Unpack)
                {
                    if (arguments.Input == null && arguments.Input.Length <= 0)
                    {
                        ShowHelpfulError("Must specify an 'input' file or directory.");
                        return(1);
                    }
                    if (string.IsNullOrEmpty(arguments.Output))
                    {
                        ShowHelpfulError("Must specified an 'output' file or directory.");
                        return(1);
                    }
                    if ((arguments.Platform.platform == GamePlatform.None && arguments.Platform.version != GameVersion.None) ||
                        (arguments.Platform.platform != GamePlatform.None && arguments.Platform.version == GameVersion.None))
                    {
                        ShowHelpfulError("'platform' argument require 'version' and vice-versa to define platform. Use this option only if you have problem with platform auto identifier");
                        return(1);
                    }
                }

                // BUILD PACKAGE FROM TEMPLATE
                if (arguments.Build)
                {
                    if (string.IsNullOrEmpty(arguments.Template))
                    {
                        ShowHelpfulError("Must specify an 'template' argument with path of the Rocksmith DLC template (*.dlc.xml).");
                        return(1);
                    }
                    if (string.IsNullOrEmpty(arguments.Output))
                    {
                        ShowHelpfulError("Must specified an 'output' file.");
                        return(1);
                    }
                    if (arguments.Output.IsDirectory())
                    {
                        ShowHelpfulError("The 'output' argument in 'build' command must be a file.");
                        return(1);
                    }

                    try
                    {
                        Console.WriteLine("Warning: You should load and save XML with 'RocksmithToolkitGUI 2.3.0.0' or above to make sure it is still valid and compatible with this feature!");

                        DLCPackageData info       = null;
                        var            serializer = new DataContractSerializer(typeof(DLCPackageData));
                        using (var stm = new XmlTextReader(arguments.Template))
                        {
                            info = (DLCPackageData)serializer.ReadObject(stm);
                        }

                        var gameVersion = info.GameVersion;
                        FixPaths(info, arguments.Template, gameVersion);

                        if (info.Pc)
                        {
                            DLCPackageCreator.Generate(arguments.Output, info, new Platform(GamePlatform.Pc, gameVersion));
                        }
                        if (gameVersion == GameVersion.RS2014)
                        {
                            if (info.Mac)
                            {
                                DLCPackageCreator.Generate(arguments.Output, info, new Platform(GamePlatform.Mac, gameVersion));
                            }
                        }
                        if (info.XBox360)
                        {
                            DLCPackageCreator.Generate(Path.Combine(Path.GetDirectoryName(arguments.Output), Path.GetFileNameWithoutExtension(arguments.Output)), info, new Platform(GamePlatform.XBox360, gameVersion));
                        }
                        if (info.PS3)
                        {
                            DLCPackageCreator.Generate(Path.Combine(Path.GetDirectoryName(arguments.Output), Path.GetFileNameWithoutExtension(arguments.Output)), info, new Platform(GamePlatform.PS3, gameVersion));
                        }

                        Console.WriteLine("Package was generated.");
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine(String.Format("{0}\n{1}\n{2}", "Build error!", ex.Message, ex.InnerException));
                        return(1);
                    }
                }

                // PACK A FOLDER TO A PACKAGE
                if (arguments.Pack)
                {
                    if (!arguments.Input[0].IsDirectory())
                    {
                        ShowHelpfulError("The 'input' argument in 'pack' command must be a directory.");
                        return(1);
                    }

                    var srcFiles = arguments.Input;
                    foreach (string srcFileName in srcFiles)
                    {
                        try
                        {
                            if (arguments.Platform.platform != GamePlatform.None && arguments.Platform.version != GameVersion.None)
                            {
                                Packer.Pack(Path.GetFullPath(srcFileName), Path.GetFullPath(arguments.Output), arguments.Platform, arguments.UpdateSng, arguments.UpdateManifest);
                            }
                            else
                            {
                                Packer.Pack(Path.GetFullPath(srcFileName), Path.GetFullPath(arguments.Output), null, arguments.UpdateSng, arguments.UpdateManifest);
                            }

                            Console.WriteLine("Packing is complete.");
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine(String.Format("Packing error!\nFile: {0}\n{1}\n{2}", srcFileName, ex.Message, ex.InnerException));
                            return(1);
                        }
                    }
                }

                // UNPACK A PACKAGE FILE
                if (arguments.Unpack)
                {
                    if (!arguments.Output.IsDirectory())
                    {
                        ShowHelpfulError("The 'output' argument in 'unpack' command must be a directory.");
                        return(1);
                    }

                    var srcFiles = new List <string>();

                    foreach (var name in arguments.Input)
                    {
                        if (name.IsDirectory())
                        {
                            srcFiles.AddRange(Directory.EnumerateFiles(Path.GetFullPath(name), "*.psarc", SearchOption.AllDirectories));
                        }
                        if (File.Exists(name))
                        {
                            srcFiles.Add(name);
                        }
                    }

                    foreach (string srcFileName in srcFiles)
                    {
                        Console.WriteLine(String.Format("Unpacking File: {0}", srcFileName));
                        Platform platform = Packer.GetPlatform(srcFileName);
                        if (platform.platform == GamePlatform.None)
                        {
                            Console.WriteLine("Error: Platform not found or invalid 'input' file:" + srcFileName);
                            continue;
                        }

                        try
                        {
                            var unpackedDir = Packer.Unpack(Path.GetFullPath(srcFileName), Path.GetFullPath(arguments.Output), null, arguments.DecodeOGG, arguments.OverwriteSongXml);

                            // create template xml file
                            if (arguments.CreateTemplateXml)
                            {
                                Console.WriteLine(String.Format("Creating Template XML file for: '{0}'", Path.GetFileName(srcFileName)));
                                CreateTemplate(unpackedDir, platform);
                            }
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine(String.Format("Unpacking error!\nFile: {0}\n{1}\n{2}", srcFileName, ex.Message, ex.InnerException));
                            return(1);
                        }
                    }

                    Console.WriteLine("Unpacking is complete.");
                }
            }
            catch (OptionException ex)
            {
                ShowHelpfulError(ex.Message);
                return(1);
            }

#if DEBUG
            Console.WriteLine("");
            Console.WriteLine("Press any key to close window ...");
            Console.ReadLine();
#endif
            return(0);
        }
        public ArrangementForm(Arrangement arrangement, DLCPackageCreator control, GameVersion gameVersion)
        {
            InitializeComponent();
            currentGameVersion = gameVersion == GameVersion.RS2012 ? GameVersion.RS2012 : GameVersion.RS2014;

            FillTuningCombo(arrangement.ArrangementType, currentGameVersion);

            foreach (var val in Enum.GetValues(typeof(ArrangementType)))
                arrangementTypeCombo.Items.Add(val);

            // this is a giant EH - careful
            arrangementTypeCombo.SelectedValueChanged += (sender, e) =>
            {
                // Selecting defaults
                var selectedType = ((ArrangementType)((ComboBox)sender).SelectedItem);

                switch (selectedType)
                {
                    case ArrangementType.Bass:
                        arrangementNameCombo.Items.Clear();
                        arrangementNameCombo.Items.Add(ArrangementName.Bass);
                        arrangementNameCombo.SelectedItem = ArrangementName.Bass;
                        break;
                    case ArrangementType.Vocal:
                        arrangementNameCombo.Items.Clear();
                        arrangementNameCombo.Items.Add(ArrangementName.Vocals);
                        arrangementNameCombo.Items.Add(ArrangementName.JVocals);
                        arrangementNameCombo.SelectedItem = ArrangementName.Vocals;
                        break;
                    case ArrangementType.ShowLight:
                        arrangementNameCombo.Items.Clear();
                        arrangementNameCombo.Items.Add(ArrangementName.ShowLights);
                        arrangementNameCombo.SelectedItem = ArrangementName.ShowLights;
                        break;
                    default:
                        arrangementNameCombo.Items.Clear();
                        arrangementNameCombo.Items.Add(ArrangementName.Combo);
                        arrangementNameCombo.Items.Add(ArrangementName.Lead);
                        arrangementNameCombo.Items.Add(ArrangementName.Rhythm);
                        arrangementNameCombo.SelectedItem = ArrangementName.Lead;
                        break;
                }

                var selectedArrangementName = (ArrangementName)arrangementNameCombo.SelectedItem;

                // Disabling options that are not meant for Arrangement Types
                // Arrangement Information
                arrangementNameCombo.Enabled = selectedType != ArrangementType.Bass;
                tuningComboBox.Enabled = (selectedType != ArrangementType.Vocal && selectedType != ArrangementType.ShowLight);
                gbTuningPitch.Enabled = (selectedType != ArrangementType.Vocal && selectedType != ArrangementType.ShowLight) && currentGameVersion != GameVersion.RS2012;
                gbScrollSpeed.Enabled = (selectedType != ArrangementType.Vocal && selectedType != ArrangementType.ShowLight);
                Picked.Enabled = selectedType == ArrangementType.Bass;
                BonusCheckBox.Enabled = gbTuningPitch.Enabled;
                MetronomeCb.Enabled = gbTuningPitch.Enabled;

                // Gameplay Path
                UpdateRouteMaskPath(selectedType, selectedArrangementName);

                // Tone Selector
                gbTone.Enabled = (selectedType != ArrangementType.Vocal && selectedType != ArrangementType.ShowLight);

                // Arrangement ID
                MasterId.Enabled = true;
                PersistentId.Enabled = true;

                // Tuning Edit
                tuningEditButton.Enabled = (selectedType != ArrangementType.Vocal && selectedType != ArrangementType.ShowLight);

                // Vocal/ShowLights Edit
                typeEdit.Enabled = (selectedType == ArrangementType.Vocal || selectedType == ArrangementType.ShowLight);

                // Update tuningComboBox
                if ((selectedType != ArrangementType.Vocal && selectedType != ArrangementType.ShowLight))
                    FillTuningCombo(selectedType, currentGameVersion);

            };

            // this EH may cause serious brain damage
            arrangementNameCombo.SelectedValueChanged += (sender, e) =>
            {
                var selectedType = ((ArrangementType)arrangementTypeCombo.SelectedItem);
                var selectedArrangementName = ((ArrangementName)((ComboBox)sender).SelectedItem);
                UpdateRouteMaskPath(selectedType, selectedArrangementName);
            };

            // this EH may cause serious brain damage
            tuningComboBox.SelectedValueChanged += (sender, e) =>
            {
                // Selecting defaults
                var selectedType = (ArrangementType)arrangementTypeCombo.SelectedItem;
                var selectedTuning = (TuningDefinition)((ComboBox)sender).SelectedItem;
                tuningEditButton.Enabled = (selectedType != ArrangementType.Vocal && selectedType != ArrangementType.ShowLight) && selectedTuning != null;
            };

            parentControl = control;
            SetupTones(arrangement);
            Arrangement = arrangement; // total update by SET action
            EditMode = routeMaskNoneRadio.Checked;
        }
        private static void PackXBox360(string sourcePath, string saveFileName, Platform platform, bool updateSng, bool updateManifest)
        {
            if (updateSng && platform.version == GameVersion.RS2014)
            {
                UpdateSng2014(sourcePath, platform);
                UpdateManifest2014(sourcePath, platform);
            }

            var songData    = new DLCPackageData();
            var packageRoot = Path.Combine(sourcePath, ROOT_XBox360);

            // If 'Root' directory doesn't exist the packing is a conversion process from another platform
            if (!Directory.Exists(packageRoot))
            {
                var songXmlFiles = Directory.EnumerateFiles(sourcePath, "*_*.xml", SearchOption.AllDirectories);

                var songTitle = String.Empty;
                foreach (var xml in songXmlFiles)
                {
                    if (Path.GetFileNameWithoutExtension(xml).ToLower().Contains("vocal") || Path.GetFileNameWithoutExtension(xml).ToLower().Contains("showlight"))
                    {
                        continue;
                    }

                    var song = Song2014.LoadFromFile(xml);

                    songData.SongInfo = new SongInfo();
                    songData.SongInfo.SongDisplayName = songTitle = song.Title;
                    songData.SongInfo.Artist          = song.ArtistName;

                    songData.SignatureType = PackageMagic.CON;
                    break;
                }

                var directoryList = Directory.GetDirectories(sourcePath, "*", SearchOption.AllDirectories);
                var fileList      = Directory.EnumerateFiles(sourcePath, "*.*", SearchOption.AllDirectories);

                // MAKE THE XBOX360 EXPECTED STRUCTURE TO PACK WORK
                var newPackageName = songTitle.GetValidSongName(songTitle).ToLower();
                var newSongDir     = Path.Combine(packageRoot, newPackageName);

                // Creating new directories
                Directory.CreateDirectory(packageRoot);
                Directory.CreateDirectory(newSongDir);

                // Create PackageList file
                var packListFile = Path.Combine(packageRoot, "PackageList.txt");
                File.WriteAllText(packListFile, newPackageName);

                // Move directories to new path
                foreach (string dir in directoryList)
                {
                    Directory.CreateDirectory(dir.Replace(sourcePath, newSongDir));
                }

                // Move files to new path
                foreach (string file in fileList)
                {
                    File.Move(file, file.Replace(sourcePath, newSongDir));
                }

                // Delete old empty directories
                foreach (string emptyDir in directoryList)
                {
                    DirectoryExtension.SafeDelete(emptyDir);
                }
            }

            foreach (var directory in Directory.EnumerateDirectories(packageRoot))
            {
                PackInnerXBox360(packageRoot, directory);
            }

            IEnumerable <string> xboxHeaderFiles = Directory.EnumerateFiles(sourcePath, "*.txt", SearchOption.TopDirectoryOnly);

            if (xboxHeaderFiles.Count() == 1)
            {
                foreach (var file in xboxHeaderFiles)
                {
                    try
                    {
                        string[] xboxHeader = File.ReadAllLines(file);
                        if (xboxHeader != null && xboxHeader.Length > 73)
                        {
                            if (xboxHeader[0].IndexOf("LIVE") > 0)
                            {
                                songData.SignatureType = PackageMagic.LIVE;

                                for (int i = 2; i <= 48; i = i + 3)
                                {
                                    long id   = Convert.ToInt64(xboxHeader[i].GetHeaderValue(), 16);
                                    int  bit  = Convert.ToInt32(xboxHeader[i + 1].GetHeaderValue());
                                    int  flag = Convert.ToInt32(xboxHeader[i + 2].GetHeaderValue());

                                    if (id != 0)
                                    {
                                        songData.XBox360Licenses.Add(new XBox360License()
                                        {
                                            ID = id, Bit = bit, Flag = flag
                                        });
                                    }
                                }
                            }

                            string songInfo = xboxHeader[74];

                            int    index      = songInfo.IndexOf(" by ");
                            string songTitle  = (index > 0) ? songInfo.Substring(0, index) : songInfo;
                            string songArtist = (index > 4) ? songInfo.Substring(index + 4) : songInfo;

                            if (!String.IsNullOrEmpty(songInfo))
                            {
                                songData.SongInfo = new SongInfo();
                                songData.SongInfo.SongDisplayName = songInfo;
                                songData.SongInfo.Artist          = songInfo;
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        throw new InvalidDataException("XBox360 header file (.txt) not found or is invalid. " + Environment.NewLine +
                                                       "The file is in the same level at 'Root' folder along with the files: 'Content image.png' and 'Package image.png' and no other file .txt can be here.", ex);
                    }
                }
            }

            IEnumerable <string> xboxFiles = Directory.EnumerateFiles(packageRoot);

            DLCPackageCreator.BuildXBox360Package(saveFileName, songData, xboxFiles, platform.version);

            foreach (var file in xboxFiles)
            {
                if (Path.GetExtension(file) == ".psarc" && File.Exists(file))
                {
                    File.Delete(file);
                }
            }
        }
        public static string DoLikeSongPack(string srcPath, string appId = "248750")
        {
            // create SongPack directory structure
            var dlcName              = Path.GetFileName(srcPath).ToLower();
            var songPackDir          = Path.Combine(Path.GetTempPath(), String.Format("{0}_songpack_p_Pc", dlcName));
            var audioWindowDir       = Path.Combine(songPackDir, "audio", "windows");
            var flatmodelsRsDir      = Path.Combine(songPackDir, "flatmodels", "rs");
            var gamexblocksNsongsDir = Path.Combine(songPackDir, "gamexblocks", "nsongs");
            var gfxassetsAlbumArtDir = Path.Combine(songPackDir, "gfxassets", "album_art");
            var manifestSongsDir     = Path.Combine(songPackDir, "manifests", String.Format("songs_dlc_{0}", dlcName));
            var songsArrDir          = Path.Combine(songPackDir, "songs", "arr");
            var binGenericDir        = Path.Combine(songPackDir, "songs", "bin", "generic");

            if (Directory.Exists(songPackDir))
            {
                DirectoryExtension.SafeDelete(songPackDir);
            }

            Directory.CreateDirectory(songPackDir);
            Directory.CreateDirectory(audioWindowDir);
            Directory.CreateDirectory(flatmodelsRsDir);
            Directory.CreateDirectory(gamexblocksNsongsDir);
            Directory.CreateDirectory(gfxassetsAlbumArtDir);
            Directory.CreateDirectory(manifestSongsDir);
            Directory.CreateDirectory(songsArrDir);
            Directory.CreateDirectory(binGenericDir);

            // populate SongPack temporary directory
            var audioWemFiles = Directory.EnumerateFiles(srcPath, "*.wem", SearchOption.AllDirectories).ToArray();

            foreach (var wem in audioWemFiles)
            {
                File.Copy(wem, Path.Combine(audioWindowDir, Path.GetFileName(wem)));
            }

            var audioBnkFiles = Directory.EnumerateFiles(srcPath, "*.bnk", SearchOption.AllDirectories).ToArray();

            foreach (var bnk in audioBnkFiles)
            {
                File.Copy(bnk, Path.Combine(audioWindowDir, Path.GetFileName(bnk)));
            }

            var xblockFiles = Directory.EnumerateFiles(srcPath, "*.xblock", SearchOption.AllDirectories).ToArray();

            foreach (var xblock in xblockFiles)
            {
                File.Copy(xblock, Path.Combine(gamexblocksNsongsDir, Path.GetFileName(xblock)));
            }

            var albumArtFiles = Directory.EnumerateFiles(srcPath, "*.dds", SearchOption.AllDirectories).ToArray();

            foreach (var albumArt in albumArtFiles)
            {
                File.Copy(albumArt, Path.Combine(gfxassetsAlbumArtDir, Path.GetFileName(albumArt)));
            }

            var jsonFiles = Directory.EnumerateFiles(srcPath, "*.json", SearchOption.AllDirectories).ToArray();

            foreach (var json in jsonFiles)
            {
                File.Copy(json, Path.Combine(manifestSongsDir, Path.GetFileName(json)));
            }

            var hsanFiles = Directory.EnumerateFiles(srcPath, "*.hsan", SearchOption.AllDirectories).ToArray();

            foreach (var hsan in hsanFiles)
            {
                File.Copy(hsan, Path.Combine(manifestSongsDir, Path.GetFileName(hsan)));
            }

            var sngFiles = Directory.EnumerateFiles(srcPath, "*.sng", SearchOption.AllDirectories).ToArray();

            foreach (var sng in sngFiles)
            {
                File.Copy(sng, Path.Combine(binGenericDir, Path.GetFileName(sng)));
            }

            var xmlFiles = Directory.EnumerateFiles(srcPath, "*.xml", SearchOption.AllDirectories).ToArray();

            foreach (var xml in xmlFiles)
            {
                File.Copy(xml, Path.Combine(songsArrDir, Path.GetFileName(xml)));
            }

            // generate new Aggregate Graph
            var aggGraphPack = new AggregateGraph2014();

            aggGraphPack.JsonDB        = new List <GraphItem>();
            aggGraphPack.HsonDB        = new List <GraphItem>(); // used for consoles ONLY
            aggGraphPack.HsanDB        = new GraphItem();
            aggGraphPack.MusicgameSong = new List <GraphItemLLID>();
            aggGraphPack.SongXml       = new List <GraphItemLLID>();
            aggGraphPack.ShowlightXml  = new List <GraphItemLLID>();
            aggGraphPack.ImageArt      = new List <GraphItemLLID>();
            aggGraphPack.Soundbank     = new List <GraphItemLLID>();
            aggGraphPack.GameXblock    = new List <GraphItem>();

            // fix aggregate graph entries, reusing existing Persistent ID
            var currentPlatform     = new Platform(GamePlatform.Pc, GameVersion.RS2014);
            var aggregateGraphFiles = Directory.EnumerateFiles(srcPath, "*.nt", SearchOption.AllDirectories).ToArray();

            foreach (var aggGraph in aggregateGraphFiles)
            {
                var agg = LoadFromFile(aggGraph);

                foreach (var json in agg.JsonDB)
                {
                    json.Canonical        = String.Format(CANONICAL_MANIFEST_PC, dlcName);
                    json.RelPathDirectory = json.Canonical;
                    json.Tag = new List <string>();
                    json.Tag.Add(TagValue.Database.GetDescription());
                    json.Tag.Add(TagValue.JsonDB.GetDescription());
                    json.UUID        = IdGenerator.Guid();
                    json.RelPathFile = String.Format("{0}.json", json.Name);
                }

                aggGraphPack.JsonDB.AddRange(agg.JsonDB);
                aggGraphPack.MusicgameSong.AddRange(agg.MusicgameSong);
                aggGraphPack.SongXml.AddRange(agg.SongXml);
                aggGraphPack.ShowlightXml.AddRange(agg.ShowlightXml);
                aggGraphPack.ImageArt.AddRange(agg.ImageArt);
                aggGraphPack.Soundbank.AddRange(agg.Soundbank);

                aggGraphPack.GameXblock.AddRange(agg.GameXblock);
            }

            // create a single hsanDB entry
            aggGraphPack.HsanDB.Name             = String.Format("songs_dlc_{0}", dlcName);
            aggGraphPack.HsanDB.Canonical        = String.Format(CANONICAL_MANIFEST_PC, dlcName);
            aggGraphPack.HsanDB.RelPathDirectory = aggGraphPack.HsanDB.Canonical;
            aggGraphPack.HsanDB.Tag = new List <string>();
            aggGraphPack.HsanDB.Tag.Add(TagValue.Database.GetDescription());
            aggGraphPack.HsanDB.Tag.Add(TagValue.HsanDB.GetDescription());
            aggGraphPack.HsanDB.UUID        = IdGenerator.Guid();
            aggGraphPack.HsanDB.RelPathFile = String.Format("{0}.hsan", aggGraphPack.HsanDB.Name);

            var aggregateGraphFileName = Path.Combine(songPackDir, String.Format("{0}_aggregategraph.nt", dlcName));

            using (var fs = new FileStream(aggregateGraphFileName, FileMode.Create))
                using (var ms = new MemoryStream())
                {
                    aggGraphPack.Serialize(ms);
                    ms.Flush();
                    ms.Seek(0, SeekOrigin.Begin);
                    ms.CopyTo(fs);
                }

            MergeHsanFiles(songPackDir, dlcName, manifestSongsDir);

            var appIdFile = Path.Combine(songPackDir, "appid.appid");

            File.WriteAllText(appIdFile, appId);

            var toolkitVersionFile = Path.Combine(songPackDir, "toolkit.version");

            using (var fs = new FileStream(toolkitVersionFile, FileMode.Create))
                using (var ms = new MemoryStream())
                {
                    DLCPackageCreator.GenerateToolkitVersion(ms, packageComment: "SongPack Maker v1.1");
                    ms.Flush();
                    ms.Seek(0, SeekOrigin.Begin);
                    ms.CopyTo(fs);
                }

            var rootFlatFile = Path.Combine(flatmodelsRsDir, "rsenumerable_root.flat");

            using (var fs = new FileStream(rootFlatFile, FileMode.Create))
                using (var ms = new MemoryStream(Resources.rsenumerable_root))
                {
                    ms.Seek(0, SeekOrigin.Begin);
                    ms.CopyTo(fs);
                }

            var songFlatFile = Path.Combine(flatmodelsRsDir, "rsenumerable_song.flat");

            using (var fs = new FileStream(songFlatFile, FileMode.Create))
                using (var ms = new MemoryStream(Resources.rsenumerable_song))
                {
                    ms.Seek(0, SeekOrigin.Begin);
                    ms.CopyTo(fs);
                }

            return(songPackDir);
        }
Example #14
0
        public void WritePackage(string outputPath, DLCPackageData packageData)
        {
            Platform platform = outputPath.GetPlatform();

            DLCPackageCreator.Generate(outputPath, packageData, platform);
        }
        public ArrangementForm(Arrangement arrangement, DLCPackageCreator control, GameVersion gameVersion)
        {
            InitializeComponent();
            currentGameVersion = gameVersion;
            FillTuningCombo();

            foreach (var val in Enum.GetValues(typeof(ArrangementType)))
                arrangementTypeCombo.Items.Add(val);

            arrangementTypeCombo.SelectedValueChanged += (sender, e) => {
                // Selecting defaults
                var selectedType = ((ArrangementType)((ComboBox)sender).SelectedItem);

                switch (selectedType) {
                    case ArrangementType.Bass:
                        arrangementNameCombo.Items.Clear();
                        arrangementNameCombo.Items.Add(ArrangementName.Bass);
                        arrangementNameCombo.SelectedItem = ArrangementName.Bass;
                        break;
                    case ArrangementType.Vocal:
                        arrangementNameCombo.Items.Clear();
                        arrangementNameCombo.Items.Add(ArrangementName.Vocals);
                        arrangementNameCombo.SelectedItem = ArrangementName.Vocals;
                        break;
                    default:
                        arrangementNameCombo.Items.Clear();
                        arrangementNameCombo.Items.Add(ArrangementName.Combo);
                        arrangementNameCombo.Items.Add(ArrangementName.Lead);
                        arrangementNameCombo.Items.Add(ArrangementName.Rhythm);
                        arrangementNameCombo.SelectedItem = arrangement.Name;
                        break;
                }

                var selectedArrangementName = ((ArrangementName)((ComboBox)arrangementNameCombo).SelectedItem);

                // Disabling options that are not meant for Arrangement Types
                // Arrangement Information
                arrangementNameCombo.Enabled = selectedType == ArrangementType.Guitar;
                tuningComboBox.Enabled = selectedType != ArrangementType.Vocal;
                gbTuningPitch.Enabled = selectedType != ArrangementType.Vocal && currentGameVersion == GameVersion.RS2014;
                gbScrollSpeed.Enabled = selectedType != ArrangementType.Vocal;
                Picked.Enabled = selectedType == ArrangementType.Bass;
                Picked.Checked = selectedType == ArrangementType.Bass ? false : true;
                BonusCheckBox.Enabled = selectedType != ArrangementType.Vocal && currentGameVersion == GameVersion.RS2014;
                UpdateCentOffset();

                // Gameplay Path
                UpdateRouteMaskPath(selectedType, selectedArrangementName);

                // Tone Selector
                gbTone.Enabled = selectedType != ArrangementType.Vocal;

                // Arrangement ID
                MasterId.Enabled = selectedType != ArrangementType.Vocal;
                PersistentId.Enabled = selectedType != ArrangementType.Vocal;

                // Tuning Edit
                tuningEditButton.Enabled = selectedType != ArrangementType.Vocal;
            };

            arrangementNameCombo.SelectedValueChanged += (sender, e) =>
            {
                var selectedType = ((ArrangementType)((ComboBox)arrangementTypeCombo).SelectedItem);
                var selectedArrangementName = ((ArrangementName)((ComboBox)sender).SelectedItem);

                UpdateRouteMaskPath(selectedType, selectedArrangementName);
            };

            tuningComboBox.SelectedValueChanged += (sender, e) => {
                // Selecting defaults
                var selectedType = ((ArrangementType)((ComboBox)arrangementTypeCombo).SelectedItem);
                var selectedTuning = ((TuningDefinition)((ComboBox)sender).SelectedItem);
                tuningEditButton.Enabled = selectedType != ArrangementType.Vocal && selectedTuning != null;
            };

            var scrollSpeed = arrangement.ScrollSpeed;
            if (scrollSpeed == 0)
                scrollSpeed = Convert.ToInt32(ConfigRepository.Instance().GetDecimal("creator_scrollspeed") * 10);
            scrollSpeedTrackBar.Value = scrollSpeed;
            UpdateScrollSpeedDisplay();
            parentControl = control;

            //Tones setup
            SetupTones(arrangement);

            Arrangement = arrangement;
        }
Example #16
0
        static int Main(string[] args)
        {
            Console.WindowWidth     = 85;
            Console.BackgroundColor = ConsoleColor.Black;
            Console.ForegroundColor = ConsoleColor.Green;

#if (DEBUG)
            // give the progie some dumby file to work on
            args = new string[] { "D:\\Temp\\Test" };
#endif

            // catch if there are no cmd line arguments
            if (args.GetLength(0) == 0)
            {
                args = new string[] { "?" }
            }
            ;
            if (args[0].Contains("?") || args[0].ToLower().Contains("help"))
            {
                Console.WriteLine(@"Rocksmith 2012 CDCL Converter DropletApp");
                Console.WriteLine(@" - Version: " + ProjectVersion());
                Console.WriteLine(@"   Copywrite (C) 2015 CST Developers");
                Console.WriteLine();
                Console.WriteLine(@" - Purpose: Converts RS2012 CDLC dat file to RS2014 CDLC psarc file");
                Console.WriteLine();
                Console.WriteLine(@" - Usage: Drag/Drop folder with *.dat files onto the console executable icon.");
                Console.Read();
                return(0);
            }

            Console.WriteLine(@"Initializing Rocksmith 2012 CDLC Converter CLI ...");
            Console.WriteLine();
            var srcDir = args[0];

            // iterate through cdlc folders and find *.dat files
            var cdlcFilesPaths = Directory.GetFiles(srcDir, "*.dat", SearchOption.AllDirectories);
            var cdlcSaveDir    = Path.Combine(Path.GetDirectoryName(cdlcFilesPaths[0]), "Converted CDLC");

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

            foreach (var cdlcFilePath in cdlcFilesPaths)
            {
                // Unpack
                Console.WriteLine(@"Unpacking: " + Path.GetFileName(cdlcFilePath));
                var unpackedDirPath = Path.Combine(Path.GetDirectoryName(cdlcFilePath), String.Format("{0}_Pc", Path.GetFileNameWithoutExtension(cdlcFilePath)));
                var unpackedDest    = Path.GetDirectoryName(cdlcFilePath);

                if (Directory.Exists(unpackedDirPath))
                {
                    DirectoryExtension.SafeDelete(unpackedDirPath);
                }

                try
                {
                    Packer.Unpack(cdlcFilePath, unpackedDest, true, true);

                    // Load Package Data
                    Console.WriteLine(@"Converting RS2012 CDLC to RS2014 CDLC ...");
                    DLCPackageData info = new DLCPackageData(); // DLCPackageData specific to RS2
                    info = DLCPackageData.RS1LoadFromFolder(unpackedDirPath, new Platform(GamePlatform.Pc, GameVersion.RS2014), true);

                    // Convert Audio to Wem Format
                    info = ConvertAudio(info);

                    // Update Albmum Art
                    info = ConvertAlbumArt(cdlcFilePath, info);

                    foreach (var arr in info.Arrangements)
                    {
                        Console.WriteLine(@"Converting XML Arrangement: " + arr);
                        arr.SongFile.File = "";

                        if (arr.ArrangementType != ArrangementType.Vocal)
                        {
                            UpdateXml(arr, info);
                        }
                    }

                    // Repack
                    var cdlcVersion  = "c1"; // conversion 1
                    var cdlcFileName = GeneralExtensions.GetShortName("{0}_{1}_{2}", info.SongInfo.Artist, info.SongInfo.SongDisplayName, cdlcVersion, ConfigRepository.Instance().GetBoolean("creator_useacronyms"));
                    var cdlcSavePath = Path.Combine(cdlcSaveDir, cdlcFileName);
                    Console.WriteLine(@"Repacking as RS2014 CDLC: " + cdlcFileName + @".psarc");
                    Console.WriteLine("");
                    DLCPackageCreator.Generate(cdlcSavePath, info, new Platform(GamePlatform.Pc, GameVersion.RS2014), pnum: 1);
                    DirectoryExtension.SafeDelete(unpackedDirPath);
                }
                catch (Exception ex)
                {
                    Console.WriteLine(@"Conversion could not be completed: " + ex.Message);
                    Console.WriteLine();
                }
            }

            Console.WriteLine();
            Console.WriteLine(@"Done Processing CDLC Folder ...");
            Console.WriteLine(@"Converted CDLC Saved To: " + cdlcSaveDir);
            Console.WriteLine(@"Remember ... CDLC Arrangements, Tones, Volumes, etc");
            Console.WriteLine(@"can be modified using the toolkit GUI, Creator tab");
            Console.WriteLine();
            Console.WriteLine(@"Press any key to continue ...");
            Console.Read();
            return(0);
        }
Example #17
0
        private static DLCPackageData ConvertAlbumArt(string cdlcFilePath, DLCPackageData info)
        {
            var unpackedDirPath = Path.Combine(Path.GetDirectoryName(cdlcFilePath), String.Format("{0}_Pc", Path.GetFileNameWithoutExtension(cdlcFilePath)));
            //D:\Temp\Test\RS001SONG0000005_Pc\MoreThanAFeeling\GRAssets\AlbumArt
            // iterate through unpacked cdlc folder and find artwork
            var ddsFilesPath = Directory.GetFiles(unpackedDirPath, "*.dds", SearchOption.AllDirectories);

            if (!ddsFilesPath.Any())
            {
                Console.WriteLine(@"Using default album artwork");
                Console.ReadLine();
                return(info);
            }

            try
            {
                var albumArtPath = ddsFilesPath[0];
                Console.WriteLine(@"Converting album artwork using: " + Path.GetFileName(albumArtPath));
                var ddsFiles = new List <DDSConvertedFile>();

                ddsFiles.Add(new DDSConvertedFile()
                {
                    sizeX = 64, sizeY = 64, sourceFile = albumArtPath, destinationFile = GeneralExtensions.GetTempFileName(".dds")
                });
                ddsFiles.Add(new DDSConvertedFile()
                {
                    sizeX = 128, sizeY = 128, sourceFile = albumArtPath, destinationFile = GeneralExtensions.GetTempFileName(".dds")
                });
                ddsFiles.Add(new DDSConvertedFile()
                {
                    sizeX = 256, sizeY = 256, sourceFile = albumArtPath, destinationFile = GeneralExtensions.GetTempFileName(".dds")
                });

                // Convert to correct dds file sizes
                DLCPackageCreator.ToDDS(ddsFiles);

                var albumArtDir    = Path.GetDirectoryName(albumArtPath);
                var albumArtName   = String.Format("album_{0}", info.Name.ToLower().Replace("_", "").GetValidName());
                var ddsPartialPath = Path.Combine(albumArtDir, albumArtName);

                foreach (var dds in ddsFiles)
                {
                    var destAlbumArtPath = String.Format("{0}_{1}.dds", ddsPartialPath, dds.sizeX);
                    if (!File.Exists(dds.destinationFile))
                    {
                        Console.WriteLine(@"Could not convert: " + destAlbumArtPath);
                    }

                    File.Copy(dds.destinationFile, destAlbumArtPath);
                    // delete temp artwork file
                    File.Delete(dds.destinationFile);
                    dds.destinationFile = destAlbumArtPath;
                }

                // update package info with album art files
                info.ArtFiles = ddsFiles;
            }
            catch (Exception ex)
            {
                Console.WriteLine(@"Could not convert album artwork in " + Path.GetFileName(cdlcFilePath) + @": " + ex.Message);
            }

            return(info);
        }
Example #18
0
        public static bool InjectArchiveEntry(string psarcPath, string entryName,
                                              string sourcePath, bool updateToolkitVersion = false,
                                              string packageAuthor = "", string packageVersion = "1", string packageComment = "")
        {
            if (!File.Exists(psarcPath))
            {
                return(false);
            }

            int injectionCount = 2;

            if (!updateToolkitVersion)
            {
                injectionCount = 1;
            }
            else
            {
                if (String.IsNullOrEmpty(packageVersion))
                {
                    packageVersion = "1";
                }
                if (String.IsNullOrEmpty(packageAuthor))
                {
                    packageAuthor = Assembly.GetExecutingAssembly().GetName().ToString();
                }
            }

            using (PSARC archive = new PSARC(true))
                using (var psarcStream = File.OpenRead(psarcPath))
                {
                    try
                    {
                        archive.Read(psarcStream);
                        psarcStream.Dispose();

                        for (int i = 0; i < injectionCount; i++)
                        {
                            var entryStream = new MemoryStream();

                            switch (i)
                            {
                            case 0:
                                using (var sourceStream = File.OpenRead(sourcePath))
                                    sourceStream.CopyTo(entryStream);
                                break;

                            case 1:
                                DLCPackageCreator.GenerateToolkitVersion(entryStream, packageAuthor, packageVersion, packageComment);
                                entryName = "toolkit.version";
                                break;
                            }

                            entryStream.Position = 0;
                            Entry tocEntry = archive.TOC.FirstOrDefault(x => x.Name == entryName);

                            if (tocEntry != null)
                            {
                                tocEntry.Data.Dispose();
                                tocEntry.Data = null;
                                tocEntry.Data = entryStream;
                            }
                            else
                            {
                                archive.AddEntry(entryName, entryStream);

                                // evil genius ... ;) => forces archive update
                                archive.TOC.Insert(0, new Entry()
                                {
                                    Name = "NamesBlock.bin"
                                });
                            }
                        }
                    }
                    catch
                    {
                        return(false);
                    }

                    using (var fs = File.Create(psarcPath))
                        archive.Write(fs, true);

                    return(true);
                }
        }