public Showlights(DLCPackageData info)
{
ShowlightList = new List <Showlight>();
foreach (var arrangement in info.Arrangements)
{
if (arrangement.ArrangementType == Sng.ArrangementType.Vocal)
{
continue;
}
var showlightFile = Path.Combine(Path.GetDirectoryName(arrangement.SongXml.File),
Path.GetFileNameWithoutExtension(arrangement.SongXml.File) + "_showlights.xml");
if (!File.Exists(showlightFile))
{
showlightFile = Path.Combine(Path.GetDirectoryName(arrangement.SongXml.File), info.Name + "_showlights.xml");
if (PopShList(Genegate(arrangement.SongXml.File).ShowlightList))
{
continue;
}
}
if (PopShList(LoadFromFile(showlightFile).ShowlightList))
{
continue;
}
}
ShowlightList = FixShowlights(ShowlightList);
Count = ShowlightList.Count;
}
public void TestSaveTemplateFile()
{
templatePaths = new List <string>();
foreach (var srcPath in TestSettings.Instance.ResourcePaths)
{
var platform = srcPath.GetPlatform();
if (platform.version == GameVersion.RS2012)
{
packageCreator.CurrentGameVersion = GameVersion.RS2012;
}
else
{
packageCreator.CurrentGameVersion = GameVersion.RS2014;
}
DLCPackageData info = packageCreator.PackageImport(srcPath, TestSettings.Instance.TmpDestDir);
// set package version because srcPackage may not have it
packageCreator.PackageVersion = "8"; // make easy to identify
var templatePath = packageCreator.SaveTemplateFile(packageCreator.UnpackedDir, true);
if (String.IsNullOrEmpty(templatePath) || !File.Exists(templatePath))
{
Assert.Fail("Save Template File Failed ...");
}
templatePaths.Add(templatePath);
}
Assert.AreEqual(TestSettings.Instance.ResourcePaths.Count, templatePaths.Count);
}
public Showlights(DLCPackageData info)
: this()
{
// using max difficulty level and
// arrangement with most notes and chords for good results
// bass arrangement usually has few chords so not much use
int maxArrNdx = 0;
int maxNoteChordCount = 0;
for (int i = 0, arrCnt = info.Arrangements.Count; i < arrCnt; i++)
{
if (info.Arrangements[i].ArrangementType == ArrangementType.Vocal)
continue;
if (info.Arrangements[i].ArrangementType == ArrangementType.ShowLight)
continue;
if (info.Arrangements[i].SongXml.File == null)
continue;
// use max difficulty level with most notes and chords
var song = Song2014.LoadFromFile(info.Arrangements[i].SongXml.File);
var mf = new ManifestFunctions(GameVersion.RS2014);
int maxDif = mf.GetMaxDifficulty(song);
int noteCount = song.Levels[maxDif].Notes.Count();
int chordCount = song.Levels[maxDif].Chords.Count();
int noteChordCount = noteCount + chordCount;
if (noteChordCount > maxNoteChordCount)
maxArrNdx = i;
}
DoTheThing(info, info.Arrangements[maxArrNdx]);
}
public static void UpdateXml(Arrangement arr, DLCPackageData info)
{
// update xml with user modified DLCPackageData info
var songXml = Song2014.LoadFromFile(arr.SongXml.File);
arr.SongFile = new RocksmithToolkitLib.DLCPackage.AggregateGraph.SongFile {
File = ""
};
arr.Id = IdGenerator.Guid();
arr.MasterId = RandomGenerator.NextInt();
songXml.AlbumName = info.SongInfo.Album;
songXml.AlbumYear = info.SongInfo.SongYear.ToString();
songXml.ArtistName = info.SongInfo.Artist;
songXml.ArtistNameSort = info.SongInfo.ArtistSort;
songXml.AverageTempo = info.SongInfo.AverageTempo;
songXml.Title = info.SongInfo.SongDisplayName;
songXml.ToneBase = arr.ToneBase;
songXml.ToneA = arr.ToneA;
songXml.ToneB = arr.ToneB;
songXml.ToneC = arr.ToneC;
songXml.ToneD = arr.ToneD;
File.Delete(arr.SongXml.File);
using (var stream = File.OpenWrite(arr.SongXml.File))
{
songXml.Serialize(stream);
}
}
private void inlayGenerateButton_Click(object sender, EventArgs e)
{
// dlcSavePath = Path.Combine(workDir, "cgm");
using (var ofd = new SaveFileDialog())
{
ofd.FileName = InlayName.GetValidName(true, false, true, Frets24).ToLower();
ofd.Filter = "Custom Inlay DLC (*.*)|*.*";
ofd.InitialDirectory = ConfigRepository.Instance()["general_rs2014path"];
// ofd.InitialDirectory = dlcSavePath;
if (ofd.ShowDialog() != DialogResult.OK)
{
return;
}
dlcSavePath = ofd.FileName;
}
DLCPackageData packageData = new DLCPackageData();
packageData.Inlay = new InlayData();
packageData.Inlay.InlayPath = InlayFile;
packageData.Inlay.IconPath = IconFile;
packageData.Inlay.Frets24 = Frets24;
packageData.Inlay.Colored = Colored;
packageData.Inlay.DLCSixName = GeneralExtensions.RandomName(6);
// CRITICAL - 24 fret inlays have naming dependencies
if (Frets24)
{
packageData.Inlay.DLCSixName = String.Format("24fret_{0}", packageData.Inlay.DLCSixName);
}
packageData.Name = InlayName;
packageData.AppId = appIdCombo.SelectedValue.ToString();
// Saving for later
ConfigRepository.Instance()["cgm_inlayname"] = InlayName;
ConfigRepository.Instance()["cgm_24frets"] = Frets24.ToString();
ConfigRepository.Instance()["cgm_coloredinlay"] = Colored.ToString();
// Generate
if (Path.GetFileName(dlcSavePath).Contains(" ") && platformPS3.Checked)
{
if (!ConfigRepository.Instance().GetBoolean("creator_ps3pkgnamewarn"))
{
MessageBox.Show(String.Format("PS3 package name can't support space character due to encryption limitation. {0} Spaces will be automatic removed for your PS3 package name.", Environment.NewLine), MESSAGEBOX_CAPTION, MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
else
{
ConfigRepository.Instance()["creator_ps3pkgnamewarn"] = true.ToString();
}
}
if (!bwGenerate.IsBusy && packageData != null)
{
updateProgress.Visible = true;
currentOperationLabel.Visible = true;
inlayGenerateButton.Enabled = false;
bwGenerate.RunWorkerAsync(packageData);
}
}
public AttributesHeader2014(string arrangementFileName, Arrangement arrangement, DLCPackageData info, Platform platform)
{
IsVocal = arrangement.ArrangementType == Sng.ArrangementType.Vocal;
SongContent = (IsVocal) ? null : Song2014.LoadFromFile(arrangement.SongXml.File);
var dlcName = info.Name.ToLower();
var albumUrn = String.Format(URN_TEMPLATE, TagValue.Image.GetDescription(), TagValue.DDS.GetDescription(), String.Format("album_{0}", dlcName));
var jsonUrn = String.Format(URN_TEMPLATE, TagValue.Database.GetDescription(), TagValue.JsonDB.GetDescription(), String.Format("{0}_{1}", dlcName, arrangementFileName));
//FILL ATTRIBUTES
this.AlbumArt = albumUrn;
ArrangementName = arrangement.Name.ToString();
DLC = true;
DLCKey = info.Name;
LeaderboardChallengeRating = 0;
ManifestUrn = jsonUrn;
MasterID_RDV = arrangement.MasterId;
PersistentID = arrangement.Id.ToString().Replace("-", "").ToUpper();
Shipping = true;
SKU = "RS2";
SongKey = info.Name;
if (!IsVocal)
{
AlbumName = AlbumNameSort = info.SongInfo.Album;
ArtistName = info.SongInfo.Artist;
CentOffset = arrangement.TuningPitch != 0 ? TuningFrequency.Frequency2Cents(arrangement.TuningPitch) : 0.0;
ArtistNameSort = info.SongInfo.ArtistSort;
CapoFret = (arrangement.Sng2014.Metadata.CapoFretId == 0xFF) ? CapoFret = 0 : Convert.ToDecimal(arrangement.Sng2014.Metadata.CapoFretId);
DNA_Chords = arrangement.Sng2014.DNACount[(int) DNAId.Chord];
DNA_Riffs = arrangement.Sng2014.DNACount[(int) DNAId.Riff];
DNA_Solo = arrangement.Sng2014.DNACount[(int) DNAId.Solo];
NotesEasy = arrangement.Sng2014.NoteCount[0];
NotesMedium = arrangement.Sng2014.NoteCount[1];
NotesHard = arrangement.Sng2014.NoteCount[2];
EasyMastery = NotesEasy / NotesHard;
MediumMastery = NotesMedium / NotesHard;
Representative = Convert.ToInt32(!arrangement.BonusArr);
RouteMask = (int)arrangement.RouteMask;
// TODO this is not quite it but much closer
SongDiffEasy = SongContent.SongLength / NotesEasy;
SongDiffMed = SongContent.SongLength / NotesMedium;
SongDiffHard = SongContent.SongLength / NotesHard;
SongDifficulty = SongDiffHard;
SongLength = (double?)Math.Round(SongContent.SongLength, 3, MidpointRounding.AwayFromZero);
SongName = info.SongInfo.SongDisplayName;
SongNameSort = info.SongInfo.SongDisplayNameSort;
SongYear = info.SongInfo.SongYear;
var tunDef = TuningDefinitionRepository.Instance().Select(arrangement.Tuning, platform.version);
Tuning = tunDef.Tuning;
}
}
public InlayAttributes2014(DLCPackageData info)
{
var dlcName = info.Inlay.DLCSixName;
DLC = true;
LocName = Name = info.Name;
DecorativeInlays = String.Format(URN_TEMPLATE, TagValue.Application.GetDescription(), TagValue.GamebryoSceneGraph.GetDescription(), dlcName);
ManifestUrn = String.Format(URN_TEMPLATE, TagValue.Database.GetDescription(), TagValue.JsonDB.GetDescription(), String.Format("dlc_guitar_{0}", dlcName));
PreviewArt = String.Format(URN_TEMPLATE, TagValue.Image.GetDescription(), TagValue.DDS.GetDescription(), String.Format("reward_inlay_{0}", dlcName));
PersistentID = info.Inlay.Id.ToString().Replace("-", "").ToUpper();
}
public InlayAttributes2014(DLCPackageData info)
{
var dlcName = info.Inlay.DLCSixName;
DLC = true;
LocName = Name = info.Name;
DecorativeInlays = String.Format(URN_TEMPLATE, TagValue.Application.GetDescription(), TagValue.GamebryoSceneGraph.GetDescription(), dlcName);
ManifestUrn = String.Format(URN_TEMPLATE, TagValue.Database.GetDescription(), TagValue.JsonDB.GetDescription(), String.Format("dlc_guitar_{0}", dlcName));
PreviewArt = String.Format(URN_TEMPLATE, TagValue.Image.GetDescription(), TagValue.DDS.GetDescription(), String.Format("reward_inlay_{0}", dlcName));
PersistentID = info.Inlay.Id.ToString().Replace("-", "").ToUpper();
}
private void DoTheThing(DLCPackageData info, Arrangement arrangement)
{
var shlFile = Path.Combine(Path.GetDirectoryName(arrangement.SongXml.File),
arrangement.SongXml.Name + "_showlights.xml");
var shlCommon = Path.Combine(Path.GetDirectoryName(shlFile), info.Name + "_showlights.xml");
if (!File.Exists(shlCommon))
{
//Generate
GetShowlights(arrangement.SongXml.File);
return;
}
GetShowlights(shlCommon);
}
private void DoTheThing(DLCPackageData info, Arrangement arrangement)
{
var shlFile = Path.Combine(Path.GetDirectoryName(arrangement.SongXml.File),
arrangement.SongXml.Name + "_showlights.xml");
var shlCommon = Path.Combine(Path.GetDirectoryName(shlFile), info.Name + "_showlights.xml");
if (!File.Exists(shlCommon))
{
//Generate
GetShowlights(arrangement.SongXml.File);
return;
}
GetShowlights(shlCommon);
}
public AggregateGraph2014(DLCPackageData info, Platform platform, DLCPackageType dlcType = DLCPackageType.Song)
{
currentPlatform = platform;
switch (dlcType) {
case DLCPackageType.Song:
SongAggregateGraph(info, dlcType);
break;
case DLCPackageType.Lesson:
throw new NotImplementedException("Lesson package type not implemented yet :(");
case DLCPackageType.Inlay:
InlayAggregateGraph(info, dlcType);
break;
}
}
/// <summary>
/// Unpacks and Reads DLCPackageData
/// </summary>
/// <param name="fixMultitoneEx">convert multi tones to single tone, prevents some in-game hangs</param>
/// <param name="fixLowBass">fix low bass tuning issues</param>
/// <param name="decodeAudio">converts wem to ogg files</param>
/// <returns>DLCPackageData</returns>
public DLCPackageData ReadPackage(string srcPath, bool fixMultitoneEx = false, bool fixLowBass = false, bool decodeAudio = false)
{
// UNPACK
packageDir = Packer.Unpack(srcPath, Path.GetTempPath(), decodeAudio);
// REORGANIZE
packageDir = DLCPackageData.DoLikeProject(packageDir);
// LOAD DATA
DLCPackageData info = new DLCPackageData();
var packagePlatform = srcPath.GetPlatform();
info = DLCPackageData.LoadFromFolder(packageDir, packagePlatform, packagePlatform, fixMultitoneEx, fixLowBass);
return(info);
}
/// <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);
}
private static void CreateTemplate(string unpackedDir, Platform platform)
{
// create template xml files
using (var packageCreator = new RocksmithToolkitGUI.DLCPackageCreator.DLCPackageCreator())
{
DLCPackageData info = null;
if (platform.version == GameVersion.RS2014)
{
info = DLCPackageData.LoadFromFolder(unpackedDir, platform, platform, true, true);
}
else
{
info = DLCPackageData.RS1LoadFromFolder(unpackedDir, platform, false);
}
info.GameVersion = platform.version;
switch (platform.platform)
{
case GamePlatform.Pc:
info.Pc = true;
break;
case GamePlatform.Mac:
info.Mac = true;
break;
case GamePlatform.XBox360:
info.XBox360 = true;
break;
case GamePlatform.PS3:
info.PS3 = true;
break;
}
packageCreator.FillPackageCreatorForm(info, unpackedDir);
// fix descrepancies
packageCreator.CurrentGameVersion = platform.version;
//packageCreator.SelectComboAppId(info.AppId);
packageCreator.AppId = info.AppId;
// save template xml file
packageCreator.SaveTemplateFile(unpackedDir, false);
}
}
public AggregateGraph2014(DLCPackageData info, Platform platform, DLCPackageType dlcType = DLCPackageType.Song)
{
currentPlatform = platform;
switch (dlcType)
{
case DLCPackageType.Song:
SongAggregateGraph(info, dlcType);
break;
case DLCPackageType.Lesson:
throw new NotImplementedException("Lesson package type not implemented yet :(");
case DLCPackageType.Inlay:
InlayAggregateGraph(info, dlcType);
break;
}
}
public void CreateShowlights(DLCPackageData info)
{
int maxNoteChordCount = 0;
int maxArrNdx = 0;
int maxLevelNdx = 0;
// find arrangment with most notes and chords
for (int i = 0; i < info.Arrangements.Count; i++)
{
if (info.Arrangements[i].ArrangementType == ArrangementType.Vocal)
{
continue;
}
if (info.Arrangements[i].ArrangementType == ArrangementType.ShowLight)
{
continue;
}
if (info.Arrangements[i].SongXml.File == null)
{
continue;
}
var song = Song2014.LoadFromFile(info.Arrangements[i].SongXml.File);
// find level with most notes and chords
for (int j = 0; j < song.Levels.Count(); j++)
{
int noteCount = song.Levels[j].Notes.Count();
int chordCount = song.Levels[j].Chords.Count();
int noteChordCount = noteCount + chordCount;
if (noteChordCount > maxNoteChordCount)
{
maxNoteChordCount = noteChordCount;
maxArrNdx = i;
maxLevelNdx = j;
}
}
}
Generate(info.Arrangements[maxArrNdx].SongXml.File, maxLevelNdx);
AdjustShowlights(ShowlightList, info.DefaultShowlights);
Count = ShowlightList.Count;
}
private static DLCPackageData ConvertAudio(DLCPackageData info)
{
var audioPath = info.OggPath;
Console.WriteLine(@"Converting audio using: " + Path.GetFileName(audioPath));
var audioPathNoExt = Path.Combine(Path.GetDirectoryName(audioPath), Path.GetFileNameWithoutExtension(audioPath));
var oggPath = String.Format(audioPathNoExt + ".ogg");
var wavPath = String.Format(audioPathNoExt + ".wav");
var wemPath = String.Format(audioPathNoExt + ".wem");
var oggPreviewPath = String.Format(audioPathNoExt + "_preview.ogg");
var wavPreviewPath = String.Format(audioPathNoExt + "_preview.wav");
var wemPreviewPath = String.Format(audioPathNoExt + "_preview.wem");
var audioPreviewPath = wemPreviewPath;
//RS1 old ogg was actually wwise
if (audioPath.Substring(audioPath.Length - 4).ToLower() == ".ogg")
{
ExternalApps.Ogg2Wav(audioPath, wavPath);
if (!File.Exists(oggPreviewPath))
{
ExternalApps.Ogg2Preview(audioPath, oggPreviewPath);
ExternalApps.Ogg2Wav(oggPreviewPath, wavPreviewPath);
}
audioPath = wavPath;
}
if (audioPath.Substring(audioPath.Length - 4).ToLower() == ".wav")
{
if (!File.Exists(wavPreviewPath))
{
ExternalApps.Wav2Ogg(audioPath, oggPath, 4);
ExternalApps.Ogg2Preview(oggPath, oggPreviewPath);
ExternalApps.Ogg2Wav(oggPreviewPath, wavPreviewPath);
}
Wwise.Convert2Wem(audioPath, wemPath, 4); // default audio quality = 4
audioPath = wemPath;
}
info.OggPath = audioPath;
info.OggPreviewPath = audioPreviewPath;
return(info);
}
private static void FixPaths(DLCPackageData info, string templateDir, GameVersion gameVersion)
{
foreach (var arr in info.Arrangements)
{
arr.SongXml.File = Path.Combine(Path.GetDirectoryName(templateDir), arr.SongXml.File);
if (gameVersion == GameVersion.RS2014)
{
UpdateTones(arr);
}
}
info.AlbumArtPath = Path.Combine(Path.GetDirectoryName(templateDir), info.AlbumArtPath);
if (!String.IsNullOrEmpty(info.OggPath))
{
info.OggPath = Path.Combine(Path.GetDirectoryName(templateDir), info.OggPath);
}
if (!String.IsNullOrEmpty(info.OggPreviewPath))
{
info.OggPreviewPath = Path.Combine(Path.GetDirectoryName(templateDir), info.OggPreviewPath);
}
}
/// <summary>
/// Loads DLCPackageData from unpacked archive (RS1 and RS2014 Compatible)
/// </summary>
/// <param name="fixMultitoneEx">convert multi tones to single tone, prevents some in-game hangs</param>
/// <param name="fixLowBass">fix low bass tuning issues</param>
/// <param name="decodeAudio">converts wem to ogg files</param>
/// <returns>DLCPackageData</returns>
public DLCPackageData ReadPackage(string srcPath, bool fixMultiTone = false, bool fixLowBass = false, bool decodeAudio = false)
{
// UNPACK
packageDir = Packer.Unpack(srcPath, Path.GetTempPath(), decodeAudio: decodeAudio);
// LOAD DLCPackageData
var srcPlatform = Packer.GetPlatform(srcPath);
DLCPackageData info = null;
if (srcPlatform.version == GameVersion.RS2014)
{
// REORGANIZE (RS2014)
packageDir = DLCPackageData.DoLikeProject(packageDir);
info = DLCPackageData.LoadFromFolder(packageDir, srcPlatform, srcPlatform, fixMultiTone, fixLowBass);
}
else
{
info = DLCPackageData.RS1LoadFromFolder(packageDir, srcPlatform, false);
}
return(info);
}
public Showlights(DLCPackageData info)
: this()
{
// using max difficulty level and
// arrangement with most notes and chords for good results
// bass arrangement usually has few chords so not much use
int maxArrNdx = 0;
int maxNoteChordCount = 0;
for (int i = 0, arrCnt = info.Arrangements.Count; i < arrCnt; i++)
{
if (info.Arrangements[i].ArrangementType == ArrangementType.Vocal)
{
continue;
}
if (info.Arrangements[i].ArrangementType == ArrangementType.ShowLight)
{
continue;
}
if (info.Arrangements[i].SongXml.File == null)
{
continue;
}
// use max difficulty level with most notes and chords
var song = Song2014.LoadFromFile(info.Arrangements[i].SongXml.File);
var mf = new ManifestFunctions(GameVersion.RS2014);
int maxDif = mf.GetMaxDifficulty(song);
int noteCount = song.Levels[maxDif].Notes.Count();
int chordCount = song.Levels[maxDif].Chords.Count();
int noteChordCount = noteCount + chordCount;
if (noteChordCount > maxNoteChordCount)
{
maxArrNdx = i;
}
}
DoTheThing(info, info.Arrangements[maxArrNdx]);
}
public DLCPackageData ReadPackage(string inputPath)
{
// UNPACK
packageDir = Packer.Unpack(inputPath, Path.GetTempPath(), true);
// REORGANIZE
packageDir = DLCPackageData.DoLikeProject(packageDir);
// LOAD DATA
DLCPackageData info = new DLCPackageData();
var packagePlatform = inputPath.GetPlatform();
info = DLCPackageData.LoadFromFolder(packageDir, packagePlatform, packagePlatform);
var foundShowlights = Directory.EnumerateFiles(packageDir, "*_showlights.xml", SearchOption.AllDirectories).Any();
// toolkit will generate showlights if none was found
if (!foundShowlights)
{
info.Showlights = true;
}
return(info);
}
public void TestPackageImport()
{
unpackedDirs = new List <string>();
foreach (var srcPath in TestSettings.Instance.ResourcePaths)
{
DLCPackageData info = new DLCPackageData();
var platform = srcPath.GetPlatform();
if (platform.version == GameVersion.RS2012)
{
packageCreator.CurrentGameVersion = GameVersion.RS2012;
}
else
{
packageCreator.CurrentGameVersion = GameVersion.RS2014;
}
info = packageCreator.PackageImport(srcPath, TestSettings.Instance.TmpDestDir);
// validate critical packageCreator/info data
Assert.IsNotNull(info);
Assert.IsNotNullOrEmpty(packageCreator.DLCKey);
// consoles do not have AppId, test AppId all other platforms
if (!info.PS3 && !info.XBox360)
{
Assert.IsNotNullOrEmpty(info.AppId);
}
// test that UnpackedDir was created
if (String.IsNullOrEmpty(packageCreator.UnpackedDir) || !Directory.Exists(packageCreator.UnpackedDir))
{
Assert.Fail("PackageImport failed to create unpackDir for: " + Path.GetFileName(srcPath));
}
unpackedDirs.Add(packageCreator.UnpackedDir);
}
Assert.AreEqual(TestSettings.Instance.ResourcePaths.Count, unpackedDirs.Count);
}
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);
}
public AttributesHeader2014(string arrangementFileName, Arrangement arrangement, DLCPackageData info, Platform platform)
{
if (arrangement.ArrangementType == ArrangementType.ShowLight)
{
return;
}
IsVocal = arrangement.ArrangementType == ArrangementType.Vocal;
song2014 = (IsVocal) ? null : Song2014.LoadFromFile(arrangement.SongXml.File);
var dlcName = info.Name.ToLower();
var albumUrn = String.Format(URN_TEMPLATE, TagValue.Image.GetDescription(), TagValue.DDS.GetDescription(), String.Format("album_{0}", dlcName));
var jsonUrn = String.Format(URN_TEMPLATE, TagValue.Database.GetDescription(), TagValue.JsonDB.GetDescription(), String.Format("{0}_{1}", dlcName, arrangementFileName));
//FILL ATTRIBUTES
this.AlbumArt = albumUrn;
JapaneseVocal |= arrangement.ArrangementName == Sng.ArrangementName.JVocals;
ArrangementName = IsVocal ? Sng.ArrangementName.Vocals.ToString() : arrangement.ArrangementName.ToString(); //HACK: weird vocals stuff
DLCKey = info.Name; // in RS2 DLCKey = SongKey, in RS1 they are different
SongKey = info.Name;
LeaderboardChallengeRating = 0;
ManifestUrn = jsonUrn;
MasterID_RDV = arrangement.MasterId; // must be unique else in-game hang occures
PersistentID = arrangement.Id.ToString().Replace("-", "").ToUpper();
Shipping = true; // false = hides the arrangement in-game
// DLC property controls whether album artwork marker is shown in-game setlist, but
// has side effect that 'Alternate Arrangements' are locked for newer player profiles
DLC = true; // false = requires UPlay to unlock
// TODO: monitor this change
if (info.ToolkitInfo == null || info.ToolkitInfo.PackageAuthor == "Ubisoft")
{
SKU = "RS2"; // shows purple marker w/ "DLC" text overlay
}
else
{
SKU = ""; // hides album artwork marker in-game setlist
}
// this SKU and DLCKey combination shows black marker w/ "RS1" text overlay on album artwork in-game setlist
// SKU = "RS1";
// DLCKey = "RS1CompatibilityDisc";
if (IsVocal)
{
return;
}
// added better AlbumNameSort feature
AlbumName = info.SongInfo.Album;
AlbumNameSort = info.SongInfo.AlbumSort;
ArtistName = info.SongInfo.Artist;
CentOffset = (!arrangement.TuningPitch.Equals(0)) ? TuningFrequency.Frequency2Cents(arrangement.TuningPitch) : 0.0;
ArtistNameSort = info.SongInfo.ArtistSort;
BassPick = arrangement.ArrangementType == ArrangementType.Bass ? (int)arrangement.PluckedType : 0;
CapoFret = (arrangement.Sng2014.Metadata.CapoFretId == 0xFF) ? CapoFret = 0 : Convert.ToDecimal(arrangement.Sng2014.Metadata.CapoFretId);
DNA_Chords = arrangement.Sng2014.DNACount[(int)DNAId.Chord];
DNA_Riffs = arrangement.Sng2014.DNACount[(int)DNAId.Riff];
DNA_Solo = arrangement.Sng2014.DNACount[(int)DNAId.Solo];
NotesEasy = arrangement.Sng2014.NoteCount[0];
NotesMedium = arrangement.Sng2014.NoteCount[1];
NotesHard = arrangement.Sng2014.NoteCount[2];
EasyMastery = Math.Round((double)(NotesEasy / NotesHard), 9);
MediumMastery = Math.Round((double)(NotesMedium / NotesHard), 9);
Metronome = arrangement.Metronome == Sng.Metronome.None ? null : (int?)arrangement.Metronome;
// TODO: monitor this change
// Representative = Convert.ToInt32(!arrangement.BonusArr);
Representative = arrangement.ArrangementPropeties.Represent;
RouteMask = (int)arrangement.RouteMask;
ManifestFunctions.GetSongDifficulty(this, song2014);
SongLength = Math.Round(song2014.SongLength, 3, MidpointRounding.AwayFromZero);
SongName = info.SongInfo.SongDisplayName;
SongNameSort = info.SongInfo.SongDisplayNameSort;
JapaneseSongName = string.IsNullOrEmpty(info.SongInfo.JapaneseSongName) ? null : info.SongInfo.JapaneseSongName;
JapaneseArtistName = string.IsNullOrEmpty(info.SongInfo.JapaneseArtistName) ? null : info.SongInfo.JapaneseArtistName;
SongYear = info.SongInfo.SongYear;
//Detect tuning
var tuning = TuningDefinitionRepository.Instance.Detect(song2014.Tuning, platform.version, arrangement.ArrangementType == ArrangementType.Bass);
Tuning = tuning.Tuning; //can we just use SongContent.Tuning
}
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
}
}
public Attributes2014(string arrangementFileName, Arrangement arrangement, DLCPackageData info, Platform platform)
: base(arrangementFileName, arrangement, info, platform)
{
#region VARIABLES
var dlcName = info.Name.ToLower();
var xblockUrn = String.Format(URN_TEMPLATE_SHORT, TagValue.EmergentWorld.GetDescription(), dlcName);
var showlightUrn = String.Format(URN_TEMPLATE, TagValue.Application.GetDescription(), TagValue.XML.GetDescription(), String.Format("{0}_showlights", dlcName));
var songXmlUrn = String.Format(URN_TEMPLATE, TagValue.Application.GetDescription(), TagValue.XML.GetDescription(), String.Format(AggregateGraph2014.NAME_ARRANGEMENT, dlcName, arrangementFileName));
var songSngUrn = String.Format(URN_TEMPLATE, TagValue.Application.GetDescription(), TagValue.MusicgameSong.GetDescription(), String.Format(AggregateGraph2014.NAME_ARRANGEMENT, dlcName, arrangementFileName));
var manifestFunctions = new ManifestFunctions(platform.version);
#endregion
#region FILL ATTRIBUTES
ArrangementSort = arrangement.ArrangementSort;
BlockAsset = xblockUrn;
manifestFunctions.GenerateDynamicVisualDensity(this, SongContent, arrangement);
FullName = String.Format(AggregateGraph2014.NAME_ARRANGEMENT, info.Name, arrangement.Name);
MasterID_PS3 = (IsVocal) ? -1 : arrangement.MasterId;
MasterID_Xbox360 = (IsVocal) ? -1 : arrangement.MasterId;
PreviewBankPath = String.Format("song_{0}_preview.bnk", info.Name.ToLower());
RelativeDifficulty = 0; //Always 0 in RS2014
ShowlightsXML = showlightUrn;
SongAsset = songSngUrn;
SongBank = String.Format("song_{0}.bnk", info.Name.ToLower());
SongEvent = String.Format("Play_{0}", info.Name);
SongXml = songXmlUrn;
SongVolume = info.Volume;
PreviewVolume = (info.PreviewVolume != null) ? info.PreviewVolume : SongVolume;
// Only for Vocal
if (IsVocal)
InputEvent = "Play_Tone_Standard_Mic";
// Only for instruments
if (!IsVocal)
{
ArrangementProperties = SongContent.ArrangementProperties;
ArrangementProperties.BassPick = (int)arrangement.PluckedType;
ArrangementProperties.PathLead = Convert.ToInt32(arrangement.RouteMask == DLCPackage.RouteMask.Lead);
ArrangementProperties.PathRhythm = Convert.ToInt32(arrangement.RouteMask == DLCPackage.RouteMask.Rhythm);
ArrangementProperties.PathBass = Convert.ToInt32(arrangement.RouteMask == DLCPackage.RouteMask.Bass);
ArrangementProperties.RouteMask = (int)arrangement.RouteMask;
// BONUS ARRANGEMENT
ArrangementProperties.BonusArr = Convert.ToInt32(arrangement.BonusArr);
if (arrangement.Name == Sng.ArrangementName.Combo)
{ //Exclusive condition
if (arrangement.RouteMask == DLCPackage.RouteMask.Lead)
ArrangementType = (int)Sng.ArrangementName.Lead;
else if (arrangement.RouteMask == DLCPackage.RouteMask.Rhythm)
ArrangementType = (int)Sng.ArrangementName.Rhythm;
else
ArrangementType = (int)arrangement.Name;
}
else
ArrangementType = (int)arrangement.Name;
//Chords -- //TODO: MISSING GENERATE
ChordTemplates = new List<ChordTemplate>();
manifestFunctions.GenerateChordTemplateData(this, SongContent);
LastConversionDateTime = SongContent.LastConversionDateTime;
MaxPhraseDifficulty = manifestFunctions.GetMaxDifficulty(SongContent);
TargetScore = 100000;
PhraseIterations = new List<PhraseIteration>();
manifestFunctions.GeneratePhraseIterationsData(this, SongContent, platform.version);
//Score_MaxNotes -- Generated on function above
//Score_PNV -- Generated on function above
Phrases = new List<Phrase>();
manifestFunctions.GeneratePhraseData(this, SongContent);
Sections = new List<Section>();
manifestFunctions.GenerateSectionData(this, SongContent);
SongAverageTempo = SongContent.AverageTempo;
SongOffset = arrangement.Sng2014.Metadata.StartTime * -1;
//SongPartition -- Generated in DLCPackageCreator after this constructor
//Techniques -- //TODO: MISSING GENERATE
//Fix for Dead tones
var it = info.TonesRS2014;
Tones = new List<Tone2014>();
Tone_A = GetToneName(arrangement.ToneA, it);
Tone_B = GetToneName(arrangement.ToneB, it);
Tone_Base = GetToneName(arrangement.ToneBase, it);
Tone_C = GetToneName(arrangement.ToneC, it);
Tone_D = GetToneName(arrangement.ToneD, it);
Tone_Multiplayer = GetToneName(arrangement.ToneMultiplayer, it);
}
#endregion
}
public Attributes2014(string arrangementFileName, Arrangement arrangement, DLCPackageData info, Platform platform)
: base(arrangementFileName, arrangement, info, platform)
{
#region VARIABLES
var dlcName = info.Name.ToLower();
var xblockUrn = String.Format(URN_TEMPLATE_SHORT, TagValue.EmergentWorld.GetDescription(), dlcName);
var showlightUrn = String.Format(URN_TEMPLATE, TagValue.Application.GetDescription(), TagValue.XML.GetDescription(), String.Format("{0}_showlights", dlcName));
var songXmlUrn = String.Format(URN_TEMPLATE, TagValue.Application.GetDescription(), TagValue.XML.GetDescription(), String.Format(AggregateGraph2014.NAME_ARRANGEMENT, dlcName, arrangementFileName));
var songSngUrn = String.Format(URN_TEMPLATE, TagValue.Application.GetDescription(), TagValue.MusicgameSong.GetDescription(), String.Format(AggregateGraph2014.NAME_ARRANGEMENT, dlcName, arrangementFileName));
var manifestFunctions = new ManifestFunctions(platform.version);
#endregion
#region FILL ATTRIBUTES
ArrangementSort = arrangement.ArrangementSort;
BlockAsset = xblockUrn;
manifestFunctions.GenerateDynamicVisualDensity(this, SongContent, arrangement);
FullName = String.Format(AggregateGraph2014.NAME_ARRANGEMENT, info.Name, arrangement.Name);
MasterID_PS3 = (IsVocal) ? -1 : arrangement.MasterId;
MasterID_Xbox360 = (IsVocal) ? -1 : arrangement.MasterId;
PreviewBankPath = String.Format("song_{0}_preview.bnk", info.Name.ToLower());
RelativeDifficulty = 0; //Always 0 in RS2014
ShowlightsXML = showlightUrn;
SongAsset = songSngUrn;
SongBank = String.Format("song_{0}.bnk", info.Name.ToLower());
SongEvent = String.Format("Play_{0}", info.Name);
SongXml = songXmlUrn;
SongVolume = info.Volume;
PreviewVolume = (info.PreviewVolume != null) ? info.PreviewVolume : SongVolume;
// Only for Vocal
if (IsVocal)
{
InputEvent = "Play_Tone_Standard_Mic";
}
// Only for instruments
if (!IsVocal)
{
ArrangementProperties = SongContent.ArrangementProperties;
ArrangementProperties.BassPick = (int)arrangement.PluckedType;
ArrangementProperties.PathLead = Convert.ToInt32(arrangement.RouteMask == DLCPackage.RouteMask.Lead);
ArrangementProperties.PathRhythm = Convert.ToInt32(arrangement.RouteMask == DLCPackage.RouteMask.Rhythm);
ArrangementProperties.PathBass = Convert.ToInt32(arrangement.RouteMask == DLCPackage.RouteMask.Bass);
ArrangementProperties.RouteMask = (int)arrangement.RouteMask;
// BONUS ARRANGEMENT
ArrangementProperties.BonusArr = Convert.ToInt32(arrangement.BonusArr);
if (arrangement.Name == Sng.ArrangementName.Combo)
{ //Exclusive condition
if (arrangement.RouteMask == DLCPackage.RouteMask.Lead)
{
ArrangementType = (int)Sng.ArrangementName.Lead;
}
else if (arrangement.RouteMask == DLCPackage.RouteMask.Rhythm)
{
ArrangementType = (int)Sng.ArrangementName.Rhythm;
}
else
{
ArrangementType = (int)arrangement.Name;
}
}
else
{
ArrangementType = (int)arrangement.Name;
}
//Chords -- //TODO: MISSING GENERATE
ChordTemplates = new List <ChordTemplate>();
manifestFunctions.GenerateChordTemplateData(this, SongContent);
LastConversionDateTime = SongContent.LastConversionDateTime;
MaxPhraseDifficulty = manifestFunctions.GetMaxDifficulty(SongContent);
TargetScore = 100000;
PhraseIterations = new List <PhraseIteration>();
manifestFunctions.GeneratePhraseIterationsData(this, SongContent, platform.version);
//Score_MaxNotes -- Generated on function above
//Score_PNV -- Generated on function above
Phrases = new List <Phrase>();
manifestFunctions.GeneratePhraseData(this, SongContent);
Sections = new List <Section>();
manifestFunctions.GenerateSectionData(this, SongContent);
SongAverageTempo = SongContent.AverageTempo;
SongOffset = arrangement.Sng2014.Metadata.StartTime * -1;
//SongPartition -- Generated in DLCPackageCreator after this constructor
//Techniques -- //TODO: MISSING GENERATE
Tone_A = arrangement.ToneA;
Tone_B = arrangement.ToneB;
Tone_Base = arrangement.ToneBase;
Tone_C = arrangement.ToneC;
Tone_D = arrangement.ToneD;
Tone_Multiplayer = arrangement.ToneMultiplayer;
Tones = new List <Tone2014>();
if (!String.IsNullOrEmpty(arrangement.ToneA))
{
Tones.Add(info.TonesRS2014.SingleOrDefault(t => t.Name == Tone_A));
}
if (!String.IsNullOrEmpty(arrangement.ToneB))
{
Tones.Add(info.TonesRS2014.SingleOrDefault(t => t.Name == Tone_B));
}
if (!String.IsNullOrEmpty(arrangement.ToneBase))
{
Tones.Add(info.TonesRS2014.SingleOrDefault(t => t.Name == Tone_Base));
}
if (!String.IsNullOrEmpty(arrangement.ToneC))
{
Tones.Add(info.TonesRS2014.SingleOrDefault(t => t.Name == Tone_C));
}
if (!String.IsNullOrEmpty(arrangement.ToneD))
{
Tones.Add(info.TonesRS2014.SingleOrDefault(t => t.Name == Tone_D));
}
if (!String.IsNullOrEmpty(arrangement.ToneMultiplayer))
{
Tones.Add(info.TonesRS2014.SingleOrDefault(t => t.Name == Tone_Multiplayer));
}
}
#endregion
}
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);
}
private void SongAggregateGraph(DLCPackageData info, DLCPackageType dlcType)
{
var dlcName = info.Name.ToLower();
var songPartition = new SongPartition();
// Xblock
var xbl = new GraphItem();
xbl.Name = dlcName;
xbl.Canonical = String.Format(CANONICAL_XBLOCK[dlcType], dlcName);
xbl.RelPathDirectory = xbl.Canonical;
xbl.Tag = new List<string>();
xbl.Tag.Add(TagValue.EmergentWorld.GetDescription());
xbl.Tag.Add(TagValue.XWorld.GetDescription());
xbl.UUID = IdGenerator.Guid();
xbl.RelPathFile = String.Format("{0}.xblock", xbl.Name);
GameXblock = xbl;
JsonDB = new List<GraphItem>();
if (currentPlatform.IsConsole)
HsonDB = new List<GraphItem>();
SongXml = new List<GraphItemLLID>();
MusicgameSong = new List<GraphItemLLID>();
foreach (var arrangement in info.Arrangements) {
var name = String.Format(NAME_ARRANGEMENT, dlcName, songPartition.GetArrangementFileName(arrangement.Name, arrangement.ArrangementType).ToLower());
// JsonDB
var json = new GraphItem();
json.Name = name;
json.Canonical = currentPlatform.IsConsole ? CANONICAL_MANIFEST_CONSOLE : 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);
JsonDB.Add(json);
//One file for each arrangement (Xbox360 / PS3 only)
if (currentPlatform.IsConsole) {
// HsonDB
var hson = new GraphItem();
hson.Name = name;
hson.Canonical = CANONICAL_MANIFEST_CONSOLE;
hson.RelPathDirectory = hson.Canonical;
hson.Tag = new List<string>();
hson.Tag.Add(TagValue.Database.GetDescription());
hson.Tag.Add(TagValue.HsonDB.GetDescription());
hson.UUID = IdGenerator.Guid();
hson.RelPathFile = String.Format("{0}.hson", json.Name);
HsonDB.Add(hson);
}
// XmlSong
var xml = new GraphItemLLID();
xml.Name = name;
xml.Canonical = String.Format(CANONICAL_XMLSONG, dlcName);
xml.RelPathDirectory = xml.Canonical;
xml.LogPathDirectory = xml.Canonical;
xml.Tag = new List<string>();
xml.Tag.Add(TagValue.Application.GetDescription());
xml.Tag.Add(TagValue.XML.GetDescription());
xml.UUID = arrangement.SongXml.UUID;
xml.LLID = Guid.Parse(arrangement.SongXml.LLID);
xml.RelPathFile = String.Format("{0}.xml", xml.Name);
xml.LogPathFile = xml.RelPathFile;
SongXml.Add(xml);
// Musicgame
var sng = new GraphItemLLID();
sng.Name = name;
sng.Canonical = String.Format(CANONICAL_GAMESONG, currentPlatform.GetPathName()[1].ToLower());
sng.RelPathDirectory = sng.Canonical;
sng.LogPathDirectory = sng.Canonical;
sng.Tag = new List<string>();
sng.Tag.Add(TagValue.Application.GetDescription());
sng.Tag.Add(TagValue.MusicgameSong.GetDescription());
if (currentPlatform.IsConsole)
sng.Tag.Add(GraphItem.GetPlatformTagDescription(currentPlatform.platform));
sng.UUID = arrangement.SongFile.UUID;
sng.LLID = Guid.Parse(arrangement.SongFile.LLID);
sng.RelPathFile = String.Format("{0}.sng", sng.Name);
sng.LogPathFile = sng.RelPathFile;
MusicgameSong.Add(sng);
}
if (currentPlatform.version == GameVersion.RS2014) {
//One file for all arrangement (PC / Mac only)
if (!currentPlatform.IsConsole) {
// HsanDB
var hsan = new GraphItem();
hsan.Name = String.Format("songs_dlc_{0}", dlcName);
hsan.Canonical = String.Format(CANONICAL_MANIFEST_PC, dlcName);
hsan.RelPathDirectory = hsan.Canonical;
hsan.Tag = new List<string>();
hsan.Tag.Add(TagValue.Database.GetDescription());
hsan.Tag.Add(TagValue.HsanDB.GetDescription());
hsan.UUID = IdGenerator.Guid();
hsan.RelPathFile = String.Format("{0}.hsan", hsan.Name);
HsanDB = hsan;
}
// Showlight (Xml)
var xml = new GraphItemLLID();
xml.Name = String.Format(NAME_SHOWLIGHT, dlcName);
xml.Canonical = String.Format(CANONICAL_XMLSONG, dlcName);
xml.RelPathDirectory = xml.Canonical;
xml.LogPathDirectory = xml.Canonical;
xml.Tag = new List<string>();
xml.Tag.Add(TagValue.Application.GetDescription());
xml.Tag.Add(TagValue.XML.GetDescription());
xml.UUID = IdGenerator.Guid();
xml.LLID = Guid.Parse(IdGenerator.LLID());
xml.RelPathFile = String.Format("{0}.xml", xml.Name);
xml.LogPathFile = xml.RelPathFile;
SongXml.Add(xml);
ShowlightXml = xml;
}
// Image Art (DDS)
var aArtArray = new string[] { info.AlbumArtPath };
if (currentPlatform.version == GameVersion.RS2014)
aArtArray = new string[] {
String.Format("album_{0}_256.dds", dlcName),
String.Format("album_{0}_128.dds", dlcName),
String.Format("album_{0}_64.dds", dlcName) };
ImageArt = new List<GraphItemLLID>();
foreach (var album in aArtArray) {
var dds = new GraphItemLLID();
dds.Canonical = CANONICAL_IMAGEART[dlcType];
dds.RelPathDirectory = dds.Canonical;
dds.LogPathDirectory = dds.Canonical;
dds.Tag = new List<string>();
dds.Tag.Add(TagValue.DDS.GetDescription());
dds.Tag.Add(TagValue.Image.GetDescription());
dds.UUID = IdGenerator.Guid();
dds.LLID = Guid.Parse(IdGenerator.LLID());
dds.Name = Path.GetFileNameWithoutExtension(album);
dds.RelPathFile = Path.GetFileName(album);
dds.LogPathFile = dds.RelPathFile;
ImageArt.Add(dds);
}
// Lyrics Font Texture
if (!String.IsNullOrEmpty(info.LyricsTex)) {
LyricsTex = new GraphItemLLID();
var tex = new GraphItemLLID();
tex.Canonical = String.Format(CANONICAL_MANIFEST_PC, dlcName);
tex.RelPathDirectory = tex.Canonical;
tex.LogPathDirectory = tex.Canonical;
tex.Tag = new List<string>();
tex.Tag.Add(TagValue.DDS.GetDescription());
tex.Tag.Add(TagValue.Image.GetDescription());
tex.UUID = IdGenerator.Guid();
tex.LLID = Guid.Parse(IdGenerator.LLID());
tex.Name = String.Format("lyrics_{0}", dlcName);
tex.RelPathFile = tex.Name;
tex.LogPathFile = tex.RelPathFile;
LyricsTex = tex;
}
// Soundbank
Soundbank = new List<GraphItemLLID>();
var bnk = new GraphItemLLID();
bnk.Canonical = String.Format(CANONICAL_SOUNDBANK, currentPlatform.GetPathName()[0].ToLower());
bnk.RelPathDirectory = bnk.Canonical;
bnk.LogPathDirectory = LOGPATH_SOUNDBANK;
bnk.Tag = new List<string>();
bnk.Tag.Add(TagValue.Audio.GetDescription());
bnk.Tag.Add(TagValue.WwiseSoundBank.GetDescription());
bnk.Tag.Add(GraphItem.GetPlatformTagDescription(currentPlatform.platform));
bnk.UUID = IdGenerator.Guid();
bnk.LLID = Guid.Parse(IdGenerator.LLID());
bnk.Name = String.Format("song_{0}", dlcName);
bnk.RelPathFile = String.Format("{0}.bnk", bnk.Name);
bnk.LogPathFile = bnk.RelPathFile;
Soundbank.Add(bnk);
if (currentPlatform.version == GameVersion.RS2014) {
// Soundbank Preview
var bnkPreview = new GraphItemLLID();
bnkPreview.Canonical = String.Format(CANONICAL_SOUNDBANK, currentPlatform.GetPathName()[0].ToLower());
bnkPreview.RelPathDirectory = bnkPreview.Canonical;
bnkPreview.LogPathDirectory = LOGPATH_SOUNDBANK;
bnkPreview.Tag = new List<string>();
bnkPreview.Tag.Add(TagValue.Audio.GetDescription());
bnkPreview.Tag.Add(TagValue.WwiseSoundBank.GetDescription());
bnkPreview.Tag.Add(GraphItem.GetPlatformTagDescription(currentPlatform.platform));
bnkPreview.UUID = IdGenerator.Guid();
bnkPreview.LLID = Guid.Parse(IdGenerator.LLID());
bnkPreview.Name = String.Format("song_{0}_preview", dlcName);
bnkPreview.RelPathFile = String.Format("{0}.bnk", bnkPreview.Name);
bnkPreview.LogPathFile = bnkPreview.RelPathFile;
Soundbank.Add(bnkPreview);
}
}
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);
}
public static GameXblock <Entity2014> Generate2014(DLCPackageData info, Platform platform, DLCPackageType dlcType = DLCPackageType.Song)
{
var game = new GameXblock <Entity2014>();
game.EntitySet = new List <Entity2014>();
var dlcName = info.Name.ToLower();
var songPartition = new SongPartition();
switch (dlcType)
{
case DLCPackageType.Song:
foreach (var arrangement in info.Arrangements)
{
if (arrangement.ArrangementType == ArrangementType.ShowLight)
{
continue;
}
var entity = new Entity2014();
var arrangementFileName = songPartition.GetArrangementFileName(arrangement.Name, arrangement.ArrangementType);
entity.Id = arrangement.Id.ToLowerId();
entity.ModelName = "RSEnumerable_Song";
entity.Name = String.Format("{0}_{1}", info.Name, arrangementFileName);
entity.Iterations = 0;
entity.Properties = new List <Property2014>();
if (platform.IsConsole)
{
entity.Properties.Add(new Property2014()
{
Name = "Header", Set = new Set()
{
Value = String.Format(URN_TEMPLATE, TagValue.Database.GetDescription(), TagValue.HsonDB.GetDescription(), String.Format(AggregateGraph2014.AggregateGraph2014.NAME_ARRANGEMENT, dlcName, arrangementFileName.ToLower()))
}
});
}
else
{
entity.Properties.Add(new Property2014()
{
Name = "Header", Set = new Set()
{
Value = String.Format(URN_TEMPLATE, TagValue.Database.GetDescription(), TagValue.HsanDB.GetDescription(), String.Format("songs_dlc_{0}", dlcName))
}
});
}
entity.Properties.Add(new Property2014()
{
Name = "Manifest", Set = new Set()
{
Value = String.Format(URN_TEMPLATE, TagValue.Database.GetDescription(), TagValue.JsonDB.GetDescription(), String.Format(AggregateGraph2014.AggregateGraph2014.NAME_ARRANGEMENT, dlcName, arrangementFileName.ToLower()))
}
});
entity.Properties.Add(new Property2014()
{
Name = "SngAsset", Set = new Set()
{
Value = String.Format(URN_TEMPLATE, TagValue.Application.GetDescription(), TagValue.MusicgameSong.GetDescription(), String.Format(AggregateGraph2014.AggregateGraph2014.NAME_ARRANGEMENT, dlcName, arrangementFileName.ToLower()))
}
});
entity.Properties.Add(new Property2014()
{
Name = "AlbumArtSmall", Set = new Set()
{
Value = String.Format(URN_TEMPLATE, TagValue.Image.GetDescription(), TagValue.DDS.GetDescription(), String.Format("album_{0}_64", dlcName))
}
});
entity.Properties.Add(new Property2014()
{
Name = "AlbumArtMedium", Set = new Set()
{
Value = String.Format(URN_TEMPLATE, TagValue.Image.GetDescription(), TagValue.DDS.GetDescription(), String.Format("album_{0}_128", dlcName))
}
});
entity.Properties.Add(new Property2014()
{
Name = "AlbumArtLarge", Set = new Set()
{
Value = String.Format(URN_TEMPLATE, TagValue.Image.GetDescription(), TagValue.DDS.GetDescription(), String.Format("album_{0}_256", dlcName))
}
});
if (arrangement.ArrangementType == ArrangementType.Vocal && arrangement.CustomFont) // One per song
{
entity.Properties.Add(new Property2014()
{
Name = "LyricArt", Set = new Set()
{
Value = String.Format(URN_TEMPLATE, TagValue.Image.GetDescription(), TagValue.DDS.GetDescription(), String.Format("lyrics_{0}", dlcName))
}
});
}
else
{
entity.Properties.Add(new Property2014()
{
Name = "LyricArt", Set = new Set()
{
Value = ""
}
});
}
entity.Properties.Add(new Property2014()
{
Name = "ShowLightsXMLAsset", Set = new Set()
{
Value = String.Format(URN_TEMPLATE, TagValue.Application.GetDescription(), TagValue.XML.GetDescription(), String.Format(AggregateGraph2014.AggregateGraph2014.NAME_SHOWLIGHT, dlcName))
}
});
entity.Properties.Add(new Property2014()
{
Name = "SoundBank", Set = new Set()
{
Value = String.Format(URN_TEMPLATE, TagValue.Audio.GetDescription(), TagValue.WwiseSoundBank.GetDescription(), String.Format("song_{0}", dlcName))
}
});
entity.Properties.Add(new Property2014()
{
Name = "PreviewSoundBank", Set = new Set()
{
Value = String.Format(URN_TEMPLATE, TagValue.Audio.GetDescription(), TagValue.WwiseSoundBank.GetDescription(), String.Format("song_{0}_preview", dlcName))
}
});
game.EntitySet.Add(entity);
}
break;
case DLCPackageType.Lesson:
throw new NotImplementedException("Lesson package type not implemented yet :(");
case DLCPackageType.Inlay:
dlcName = info.Inlay.DLCSixName;
var inlayEntity = new Entity2014();
inlayEntity.Id = info.Inlay.Id.ToLowerId();
inlayEntity.ModelName = "RSEnumerable_Guitars";
inlayEntity.Name = info.Name;
inlayEntity.Iterations = 0;
inlayEntity.Properties = new List <Property2014>();
if (platform.IsConsole)
{
inlayEntity.Properties.Add(new Property2014()
{
Name = "Header", Set = new Set()
{
Value = String.Format(URN_TEMPLATE, TagValue.Database.GetDescription(), TagValue.HsonDB.GetDescription(), String.Format("dlc_{0}", dlcName))
}
});
}
else
{
inlayEntity.Properties.Add(new Property2014()
{
Name = "Header", Set = new Set()
{
Value = String.Format(URN_TEMPLATE, TagValue.Database.GetDescription(), TagValue.HsanDB.GetDescription(), String.Format("dlc_{0}", dlcName))
}
});
}
inlayEntity.Properties.Add(new Property2014()
{
Name = "Manifest", Set = new Set()
{
Value = String.Format(URN_TEMPLATE, TagValue.Database.GetDescription(), TagValue.JsonDB.GetDescription(), String.Format("dlc_guitar_{0}", dlcName))
}
});
inlayEntity.Properties.Add(new Property2014()
{
Name = "PreviewArt", Set = new Set()
{
Value = String.Format(URN_TEMPLATE, TagValue.Image.GetDescription(), TagValue.DDS.GetDescription(), String.Format("reward_inlay_{0}", dlcName))
}
});
//
inlayEntity.Properties.Add(new Property2014()
{
Name = "DecorativeInlays", Set = new Set()
{
Value = String.Format(URN_TEMPLATE, TagValue.Application.GetDescription(), TagValue.GamebryoSceneGraph.GetDescription(), dlcName)
}
});
game.EntitySet.Add(inlayEntity);
break;
}
return(game);
}
private void SongAggregateGraph(DLCPackageData info, DLCPackageType dlcType)
{
var dlcName = info.Name.ToLower();
var songPartition = new SongPartition();
// Xblock
GameXblock = new List <GraphItem>();
var xbl = new GraphItem();
xbl.Name = dlcName;
xbl.Canonical = String.Format(CANONICAL_XBLOCK[dlcType], dlcName);
xbl.RelPathDirectory = xbl.Canonical;
xbl.Tag = new List <string>();
xbl.Tag.Add(TagValue.EmergentWorld.GetDescription());
xbl.Tag.Add(TagValue.XWorld.GetDescription());
xbl.UUID = IdGenerator.Guid();
xbl.RelPathFile = String.Format("{0}.xblock", xbl.Name);
GameXblock.Add(xbl);
JsonDB = new List <GraphItem>();
if (currentPlatform.IsConsole)
{
HsonDB = new List <GraphItem>();
}
SongXml = new List <GraphItemLLID>();
MusicgameSong = new List <GraphItemLLID>();
foreach (var arrangement in info.Arrangements)
{
if (arrangement.ArrangementType == Sng.ArrangementType.ShowLight)
{
continue;
}
var name = String.Format(NAME_ARRANGEMENT, dlcName, songPartition.GetArrangementFileName(arrangement.ArrangementName, arrangement.ArrangementType).ToLower());
// JsonDB
var json = new GraphItem();
json.Name = name;
json.Canonical = currentPlatform.IsConsole ? CANONICAL_MANIFEST_CONSOLE : 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);
JsonDB.Add(json);
//One file for each arrangement (Xbox360 / PS3 only)
if (currentPlatform.IsConsole)
{
// HsonDB
var hson = new GraphItem();
hson.Name = name;
hson.Canonical = CANONICAL_MANIFEST_CONSOLE;
hson.RelPathDirectory = hson.Canonical;
hson.Tag = new List <string>();
hson.Tag.Add(TagValue.Database.GetDescription());
hson.Tag.Add(TagValue.HsonDB.GetDescription());
hson.UUID = IdGenerator.Guid();
hson.RelPathFile = String.Format("{0}.hson", json.Name);
HsonDB.Add(hson);
}
// XmlSong
var xml = new GraphItemLLID();
xml.Name = name;
xml.Canonical = String.Format(CANONICAL_XMLSONG, dlcName);
xml.RelPathDirectory = xml.Canonical;
xml.LogPathDirectory = xml.Canonical;
xml.Tag = new List <string>();
xml.Tag.Add(TagValue.Application.GetDescription());
xml.Tag.Add(TagValue.XML.GetDescription());
xml.UUID = arrangement.SongXml.UUID;
xml.LLID = IdGenerator.LLIDGuid();
xml.RelPathFile = String.Format("{0}.xml", xml.Name);
xml.LogPathFile = xml.RelPathFile;
SongXml.Add(xml);
// Musicgame
var sng = new GraphItemLLID();
sng.Name = name;
sng.Canonical = String.Format(CANONICAL_GAMESONG, currentPlatform.GetPathName()[1].ToLower());
sng.RelPathDirectory = sng.Canonical;
sng.LogPathDirectory = sng.Canonical;
sng.Tag = new List <string>();
sng.Tag.Add(TagValue.Application.GetDescription());
sng.Tag.Add(TagValue.MusicgameSong.GetDescription());
if (currentPlatform.IsConsole)
{
sng.Tag.Add(GraphItem.GetPlatformTagDescription(currentPlatform.platform));
}
sng.UUID = arrangement.SongFile.UUID;
sng.LLID = IdGenerator.LLIDGuid();
sng.RelPathFile = String.Format("{0}.sng", sng.Name);
sng.LogPathFile = sng.RelPathFile;
MusicgameSong.Add(sng);
}
if (currentPlatform.version == GameVersion.RS2014)
{
//One file for all arrangement (PC / Mac only)
if (!currentPlatform.IsConsole)
{
// HsanDB
var hsan = new GraphItem();
hsan.Name = String.Format("songs_dlc_{0}", dlcName);
hsan.Canonical = String.Format(CANONICAL_MANIFEST_PC, dlcName);
hsan.RelPathDirectory = hsan.Canonical;
hsan.Tag = new List <string>();
hsan.Tag.Add(TagValue.Database.GetDescription());
hsan.Tag.Add(TagValue.HsanDB.GetDescription());
hsan.UUID = IdGenerator.Guid();
hsan.RelPathFile = String.Format("{0}.hsan", hsan.Name);
HsanDB = hsan;
}
// Showlight (Xml)
var ShowlightXml = new List <GraphItemLLID>();
var xml = new GraphItemLLID();
xml.Name = String.Format(NAME_SHOWLIGHT, dlcName);
xml.Canonical = String.Format(CANONICAL_XMLSONG, dlcName);
xml.RelPathDirectory = xml.Canonical;
xml.LogPathDirectory = xml.Canonical;
xml.Tag = new List <string>();
xml.Tag.Add(TagValue.Application.GetDescription());
xml.Tag.Add(TagValue.XML.GetDescription());
xml.UUID = IdGenerator.Guid();
xml.LLID = IdGenerator.LLIDGuid();
xml.RelPathFile = String.Format("{0}.xml", xml.Name);
xml.LogPathFile = xml.RelPathFile;
SongXml.Add(xml); // TODO: check this
ShowlightXml.Add(xml);
}
// Image Art (DDS)
var aArtArray = new string[] { info.AlbumArtPath };
if (currentPlatform.version == GameVersion.RS2014)
{
aArtArray = new string[] {
String.Format("album_{0}_256.dds", dlcName),
String.Format("album_{0}_128.dds", dlcName),
String.Format("album_{0}_64.dds", dlcName)
}
}
;
ImageArt = new List <GraphItemLLID>();
foreach (var album in aArtArray)
{
var dds = new GraphItemLLID();
dds.Canonical = CANONICAL_IMAGEART[dlcType];
dds.RelPathDirectory = dds.Canonical;
dds.LogPathDirectory = dds.Canonical;
dds.Tag = new List <string>();
dds.Tag.Add(TagValue.DDS.GetDescription());
dds.Tag.Add(TagValue.Image.GetDescription());
dds.UUID = IdGenerator.Guid();
dds.LLID = IdGenerator.LLIDGuid();
dds.Name = Path.GetFileNameWithoutExtension(album);
dds.RelPathFile = Path.GetFileName(album);
dds.LogPathFile = dds.RelPathFile;
ImageArt.Add(dds);
}
// Lyrics Font Texture
if (!String.IsNullOrEmpty(info.LyricArtPath))
{
var dds = new GraphItemLLID();
dds.Canonical = String.Format(CANONICAL_LYRIC, dlcName);
dds.RelPathDirectory = dds.Canonical;
dds.LogPathDirectory = dds.Canonical;
dds.Tag = new List <string>();
dds.Tag.Add(TagValue.DDS.GetDescription());
dds.Tag.Add(TagValue.Image.GetDescription());
dds.UUID = IdGenerator.Guid();
dds.LLID = IdGenerator.LLIDGuid();
dds.Name = String.Format("lyrics_{0}", dlcName);
dds.RelPathFile = String.Format("{0}.dds", dds.Name); //keep extension
dds.LogPathFile = dds.RelPathFile;
ImageArt.Add(dds);
}
// Soundbank
Soundbank = new List <GraphItemLLID>();
var bnk = new GraphItemLLID();
bnk.Canonical = String.Format(CANONICAL_SOUNDBANK, currentPlatform.GetPathName()[0].ToLower());
bnk.RelPathDirectory = bnk.Canonical;
bnk.LogPathDirectory = LOGPATH_SOUNDBANK;
bnk.Tag = new List <string>();
bnk.Tag.Add(TagValue.Audio.GetDescription());
bnk.Tag.Add(TagValue.WwiseSoundBank.GetDescription());
bnk.Tag.Add(GraphItem.GetPlatformTagDescription(currentPlatform.platform));
bnk.UUID = IdGenerator.Guid();
bnk.LLID = IdGenerator.LLIDGuid();
bnk.Name = String.Format("song_{0}", dlcName);
bnk.RelPathFile = String.Format("{0}.bnk", bnk.Name);
bnk.LogPathFile = bnk.RelPathFile;
Soundbank.Add(bnk);
if (currentPlatform.version == GameVersion.RS2014)
{
// Soundbank Preview
var bnkPreview = new GraphItemLLID();
bnkPreview.Canonical = String.Format(CANONICAL_SOUNDBANK, currentPlatform.GetPathName()[0].ToLower());
bnkPreview.RelPathDirectory = bnkPreview.Canonical;
bnkPreview.LogPathDirectory = LOGPATH_SOUNDBANK;
bnkPreview.Tag = new List <string>();
bnkPreview.Tag.Add(TagValue.Audio.GetDescription());
bnkPreview.Tag.Add(TagValue.WwiseSoundBank.GetDescription());
bnkPreview.Tag.Add(GraphItem.GetPlatformTagDescription(currentPlatform.platform));
bnkPreview.UUID = IdGenerator.Guid();
bnkPreview.LLID = IdGenerator.LLIDGuid();
bnkPreview.Name = String.Format("song_{0}_preview", dlcName);
bnkPreview.RelPathFile = String.Format("{0}.bnk", bnkPreview.Name);
bnkPreview.LogPathFile = bnkPreview.RelPathFile;
Soundbank.Add(bnkPreview);
}
}
public AttributesHeader2014(string arrangementFileName, Arrangement arrangement, DLCPackageData info, Platform platform)
{
if (arrangement.ArrangementType == ArrangementType.ShowLight)
return;
IsVocal = arrangement.ArrangementType == ArrangementType.Vocal;
SongContent = (IsVocal) ? null : Song2014.LoadFromFile(arrangement.SongXml.File);
var dlcName = info.Name.ToLower();
var albumUrn = String.Format(URN_TEMPLATE, TagValue.Image.GetDescription(), TagValue.DDS.GetDescription(), String.Format("album_{0}", dlcName));
var jsonUrn = String.Format(URN_TEMPLATE, TagValue.Database.GetDescription(), TagValue.JsonDB.GetDescription(), String.Format("{0}_{1}", dlcName, arrangementFileName));
//FILL ATTRIBUTES
this.AlbumArt = albumUrn;
JapaneseVocal |= arrangement.Name == Sng.ArrangementName.JVocals;
ArrangementName = IsVocal ? Sng.ArrangementName.Vocals.ToString() : arrangement.Name.ToString(); //HACK: weird vocals stuff
DLC = true;
DLCKey = info.Name;
LeaderboardChallengeRating = 0;
ManifestUrn = jsonUrn;
MasterID_RDV = arrangement.MasterId;
PersistentID = arrangement.Id.ToString().Replace("-", "").ToUpper();
Shipping = true;
SKU = "RS2";
SongKey = info.Name; // proof same same
if (IsVocal) return;
// added better AlbumNameSort feature
AlbumName = info.SongInfo.Album;
AlbumNameSort = info.SongInfo.AlbumSort;
ArtistName = info.SongInfo.Artist;
CentOffset = (!arrangement.TuningPitch.Equals(0)) ? TuningFrequency.Frequency2Cents(arrangement.TuningPitch) : 0.0;
ArtistNameSort = info.SongInfo.ArtistSort;
if (arrangement.ArrangementType == ArrangementType.Bass)
{
SerializeBassInfo = true;
BassPick = (int) arrangement.PluckedType;
}
else
SerializeBassInfo = false;
CapoFret = (arrangement.Sng2014.Metadata.CapoFretId == 0xFF) ? CapoFret = 0 : Convert.ToDecimal(arrangement.Sng2014.Metadata.CapoFretId);
DNA_Chords = arrangement.Sng2014.DNACount[(int)DNAId.Chord];
DNA_Riffs = arrangement.Sng2014.DNACount[(int)DNAId.Riff];
DNA_Solo = arrangement.Sng2014.DNACount[(int)DNAId.Solo];
NotesEasy = arrangement.Sng2014.NoteCount[0];
NotesMedium = arrangement.Sng2014.NoteCount[1];
NotesHard = arrangement.Sng2014.NoteCount[2];
EasyMastery = NotesEasy / NotesHard;
MediumMastery = NotesMedium / NotesHard;
Metronome = (int?)arrangement.Metronome;
// TODO: check for bug here
// if there is an equivalent bonus arrangement then Representative is set to "1" otherwise "0"
Representative = Convert.ToInt32(!arrangement.BonusArr);
RouteMask = (int)arrangement.RouteMask;
// TODO: use ManifestFunctions.GetSongDifficulty() method (fix generation algorithm)
// TODO: round to 9 decimal places and improve calculation
// TODO: fix SongDiff calculations
SongDiffEasy = SongContent.SongLength / NotesEasy;
SongDiffMed = SongContent.SongLength / NotesMedium;
SongDiffHard = SongContent.SongLength / NotesHard;
SongDifficulty = SongDiffHard;
SongLength = Math.Round(SongContent.SongLength, 3, MidpointRounding.AwayFromZero);
SongName = info.SongInfo.SongDisplayName;
SongNameSort = info.SongInfo.SongDisplayNameSort;
SongYear = info.SongInfo.SongYear;
//Detect tuning
var tuning = TuningDefinitionRepository.Instance.Detect(SongContent.Tuning, platform.version, arrangement.ArrangementType == ArrangementType.Bass);
Tuning = tuning.Tuning; //can we just use SongContent.Tuning
}
private void UnpackSongs(IEnumerable <string> sourceFileNames, string destPath, bool decode = false, bool overwrite = false)
{
ToggleUIControls(false);
errorsFound = new StringBuilder();
GlobalExtension.UpdateProgress = this.pbUpdateProgress;
GlobalExtension.CurrentOperationLabel = this.lblCurrentOperation;
Thread.Sleep(100); // give Globals a chance to initialize
var structured = ConfigRepository.Instance().GetBoolean("creator_structured");
var step = (int)Math.Floor(100.0 / (sourceFileNames.Count() * 2)); // Math.Floor prevents roundup errors
int progress = 0;
Stopwatch sw = new Stopwatch();
sw.Restart();
foreach (string sourceFileName in sourceFileNames)
{
Application.DoEvents();
progress += step;
GlobalExtension.ShowProgress(String.Format("Unpacking: '{0}'", Path.GetFileName(sourceFileName)), progress);
try
{
Platform platform = sourceFileName.GetPlatform();
var unpackedDir = Packer.Unpack(sourceFileName, destPath, decode, overwrite, platform);
// added a bulk process to create template xml files here so unpacked folders may be loaded quickly in CDLC Creator if desired
progress += step;
GlobalExtension.ShowProgress(String.Format("Creating Template XML file for: '{0}'", Path.GetFileName(sourceFileName)), progress);
using (var packageCreator = new DLCPackageCreator.DLCPackageCreator())
{
DLCPackageData info = null;
if (platform.version == GameVersion.RS2014)
{
info = DLCPackageData.LoadFromFolder(unpackedDir, platform, platform, true, true);
}
else
{
info = DLCPackageData.RS1LoadFromFolder(unpackedDir, platform, false);
}
info.GameVersion = platform.version;
switch (platform.platform)
{
case GamePlatform.Pc:
info.Pc = true;
break;
case GamePlatform.Mac:
info.Mac = true;
break;
case GamePlatform.XBox360:
info.XBox360 = true;
break;
case GamePlatform.PS3:
info.PS3 = true;
break;
}
packageCreator.FillPackageCreatorForm(info, unpackedDir);
// fix descrepancies
packageCreator.CurrentGameVersion = platform.version;
//packageCreator.SelectComboAppId(info.AppId);
packageCreator.AppId = info.AppId;
// save template xml file except when SongPack
if (!sourceFileName.Contains("_sp_") && !sourceFileName.Contains("_songpack_"))
{
packageCreator.SaveTemplateFile(unpackedDir, false);
}
}
}
catch (Exception ex)
{
errorsFound.AppendLine(String.Format("Error unpacking file: '{0}' ... {1}", Path.GetFileName(sourceFileName), ex.Message));
}
}
sw.Stop();
GlobalExtension.ShowProgress("Finished unpacking archive (elapsed time): " + sw.Elapsed, 100);
PromptComplete(destPath, false, errorsFound.ToString());
GlobalExtension.Dispose();
ToggleUIControls(true);
}
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);
}
private void btnFixLowBassTuning_Click(object sender, EventArgs e)
{
string[] srcPaths;
bool alreadyFixed;
bool hasBass;
// GET PATH
using (var ofd = new OpenFileDialog())
{
ofd.Title = "Select the CDLC(s) which to apply Bass Tuning Fix";
ofd.Filter = "All Files (*.*)|*.*|Rocksmith 2014 PC|*_p.psarc|Rocksmith 2014 Mac|*_m.psarc|Rocksmith 2014 Xbox|*_xbox|Rocksmith 2014 PS3|*.edat";
ofd.Multiselect = true;
ofd.FileName = destPath;
if (ofd.ShowDialog() != DialogResult.OK)
{
return;
}
srcPaths = ofd.FileNames;
}
var fixLowBass = ConfigRepository.Instance().GetBoolean("creator_fixlowbass");
ToggleUIControls(false);
errorsFound = new StringBuilder();
GlobalExtension.UpdateProgress = this.pbUpdateProgress;
GlobalExtension.CurrentOperationLabel = this.lblCurrentOperation;
Thread.Sleep(100); // give Globals a chance to initialize
Stopwatch sw = new Stopwatch();
sw.Restart();
foreach (var srcPath in srcPaths)
{
// UNPACK
var packagePlatform = srcPath.GetPlatform();
var tmpPath = Path.GetTempPath();
Application.DoEvents();
string unpackedDir;
try
{
unpackedDir = Packer.Unpack(srcPath, tmpPath, overwriteSongXml: true, predefinedPlatform: packagePlatform);
}
catch (Exception ex)
{
errorsFound.AppendLine(String.Format("Error trying unpack file '{0}': {1}", Path.GetFileName(srcPath), ex.Message));
continue;
}
destPath = Path.Combine(Path.GetDirectoryName(srcPaths[0]), Path.GetFileName(unpackedDir));
GlobalExtension.ShowProgress(String.Format("Loading '{0}' ...", Path.GetFileName(srcPath)), 40);
// Same name xbox issue fix
//if (packagePlatform.platform == GamePlatform.XBox360)
// destPath = String.Format("{0}_{1}", destPath, GamePlatform.XBox360.ToString());
DirectoryExtension.Move(unpackedDir, destPath, true);
unpackedDir = destPath;
// Low Bass Tuning Fix is for Rocksmith 2014 Only
packagePlatform = new Platform(packagePlatform.platform, GameVersion.RS2014);
// LOAD DATA
var info = DLCPackageData.LoadFromFolder(unpackedDir, packagePlatform, packagePlatform, false);
switch (packagePlatform.platform)
{
case GamePlatform.Pc:
info.Pc = true;
break;
case GamePlatform.Mac:
info.Mac = true;
break;
case GamePlatform.XBox360:
info.XBox360 = true;
break;
case GamePlatform.PS3:
info.PS3 = true;
break;
}
//apply bass fix
GlobalExtension.ShowProgress(String.Format("Applying Bass Tuning Fix '{0}' ...", Path.GetFileName(srcPath)), 60);
alreadyFixed = false;
hasBass = false;
for (int i = 0; i < info.Arrangements.Count; i++)
{
Arrangement arr = info.Arrangements[i];
if (arr.ArrangementType == ArrangementType.Bass)
{
hasBass = true;
if (arr.TuningStrings.String0 < -4 && arr.TuningPitch != 220.0)
{
if (!TuningFrequency.ApplyBassFix(arr, fixLowBass))
{
if (chkVerbose.Checked)
{
MessageBox.Show(Path.GetFileName(srcPath) + " " + Environment.NewLine + "bass arrangement is already at 220Hz pitch. ", "Error ... Applying Low Bass Tuning Fix", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
alreadyFixed = true;
}
}
else
{
if (chkVerbose.Checked)
{
MessageBox.Show(Path.GetFileName(srcPath) + " " + Environment.NewLine + "bass arrangement tuning does not need to be fixed. ", "Error ... Applying Low Bass Tuning Fix", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
alreadyFixed = true;
}
}
}
// don't repackage a song that is already fixed or doesn't have bass
if (alreadyFixed || !hasBass)
{
if (chkVerbose.Checked && !hasBass)
{
MessageBox.Show(Path.GetFileName(srcPath) + " " + Environment.NewLine + "has no bass arrangement. ", "Error ... Applying Low Bass Tuning Fix", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
DirectoryExtension.SafeDelete(unpackedDir);
continue;
}
var ndx = srcPath.LastIndexOf('_');
var srcName = srcPath.Substring(0, ndx);
var srcExt = srcPath.Substring(ndx, srcPath.Length - ndx);
if (!chkQuickBassFix.Checked)
{
using (var ofd = new SaveFileDialog())
{
ofd.Title = "Select a name for the Low Bass Tuning Fixed file.";
ofd.Filter = "All Files (*.*)|*.*|Rocksmith 2014 PC|*_p.psarc|Rocksmith 2014 Mac|*_m.psarc|Rocksmith 2014 Xbox|*_xbox|Rocksmith 2014 PS3|*.edat";
ofd.FileName = String.Format("{0}_{1}_bassfix{2}", info.SongInfo.ArtistSort, info.SongInfo.SongDisplayNameSort, srcExt);
if (ofd.ShowDialog() != DialogResult.OK)
{
return;
}
destPath = ofd.FileName;
}
}
else
{
destPath = String.Format("{0}_bassfix{1}", srcName, srcExt);
}
if (Path.GetFileName(destPath).Contains(" ") && info.PS3)
{
if (!ConfigRepository.Instance().GetBoolean("creator_ps3pkgnamewarn"))
{
MessageBox.Show(String.Format("PS3 package name can't support space character due to encryption limitation. {0} Spaces will be automatic removed for your PS3 package name.", Environment.NewLine), MESSAGEBOX_CAPTION, MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
else
{
ConfigRepository.Instance()["creator_ps3pkgnamewarn"] = true.ToString();
}
}
if (chkDeleteSourceFile.Checked)
{
try
{
File.Delete(srcPath);
}
catch (Exception ex)
{
Console.Write(ex.Message);
MessageBox.Show("Access rights required to delete source package, or an error occurred. Package still may exist. Try running as Administrator.");
}
}
// Generate Fixed Low Bass Tuning Package
GlobalExtension.ShowProgress(String.Format("Repackaging '{0}' ...", Path.GetFileName(srcPath)), 80);
// TODO consider user of regular packer here
RocksmithToolkitLib.DLCPackage.DLCPackageCreator.Generate(destPath, info, packagePlatform);
if (!GeneralExtensions.IsInDesignMode)
{
DirectoryExtension.SafeDelete(unpackedDir);
}
}
sw.Stop();
GlobalExtension.ShowProgress("Finished applying low bass tuning fix (elapsed time): " + sw.Elapsed, 100);
if (String.IsNullOrEmpty(destPath))
{
destPath = srcPaths[0];
}
PromptComplete(destPath, errMsg: errorsFound.ToString());
GlobalExtension.Dispose();
ToggleUIControls(true);
}
private void InlayAggregateGraph(DLCPackageData info, DLCPackageType dlcType)
{
var dlcName = info.Inlay.DLCSixName;
// Xblock
var xbl = new GraphItem();
xbl.Name = String.Format("guitar_{0}", dlcName);
xbl.Canonical = String.Format(CANONICAL_XBLOCK[dlcType], dlcName);
xbl.RelPathDirectory = xbl.Canonical;
xbl.Tag = new List<string>();
xbl.Tag.Add(TagValue.EmergentWorld.GetDescription());
xbl.Tag.Add(TagValue.XWorld.GetDescription());
xbl.UUID = IdGenerator.Guid();
xbl.RelPathFile = String.Format("guitar_{0}.xblock", dlcName);
GameXblock = xbl;
// JsonDB
JsonDB = new List<GraphItem>();
var json = new GraphItem();
json.Name = String.Format("dlc_guitar_{0}", dlcName);
json.Canonical = currentPlatform.IsConsole ? CANONICAL_MANIFEST_CONSOLE : 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("dlc_guitar_{0}.json", dlcName);
JsonDB.Add(json);
if (currentPlatform.IsConsole) {
// HsonDB - One file for each manifest (Xbox360 / PS3 only)
HsonDB = new List<GraphItem>();
var hson = new GraphItem();
hson.Name = String.Format("dlc_{0}", dlcName);
hson.Canonical = CANONICAL_MANIFEST_CONSOLE;
hson.RelPathDirectory = hson.Canonical;
hson.Tag = new List<string>();
hson.Tag.Add(TagValue.Database.GetDescription());
hson.Tag.Add(TagValue.HsonDB.GetDescription());
hson.UUID = IdGenerator.Guid();
hson.RelPathFile = String.Format("dlc_{0}.hson", dlcName);
HsonDB.Add(hson);
} else {
// HsanDB - One file for all manifest (PC / Mac)
var hsan = new GraphItem();
hsan.Name = String.Format("dlc_{0}", dlcName);
hsan.Canonical = String.Format(CANONICAL_MANIFEST_PC, dlcName);
hsan.RelPathDirectory = hsan.Canonical;
hsan.Tag = new List<string>();
hsan.Tag.Add(TagValue.Database.GetDescription());
hsan.Tag.Add(TagValue.HsanDB.GetDescription());
hsan.UUID = IdGenerator.Guid();
hsan.RelPathFile = String.Format("dlc_{0}.hsan", dlcName);
HsanDB = hsan;
}
ImageArt = new List<GraphItemLLID>();
// Inlay Icon (DDS)
var aArtArray = new string[] { String.Format("reward_inlay_{0}_512", dlcName),
String.Format("reward_inlay_{0}_256", dlcName),
String.Format("reward_inlay_{0}_128", dlcName),
String.Format("reward_inlay_{0}_64", dlcName) };
foreach (var icon in aArtArray) {
var iconDDS = new GraphItemLLID();
iconDDS.Canonical = CANONICAL_IMAGEART[dlcType];
iconDDS.RelPathDirectory = iconDDS.Canonical;
iconDDS.LogPathDirectory = iconDDS.Canonical;
iconDDS.Tag = new List<string>();
iconDDS.Tag.Add(TagValue.DDS.GetDescription());
iconDDS.Tag.Add(TagValue.Image.GetDescription());
iconDDS.UUID = IdGenerator.Guid();
iconDDS.LLID = Guid.Parse(IdGenerator.LLID());
iconDDS.Name = icon;
iconDDS.RelPathFile = String.Format("{0}.dds", iconDDS.Name);
iconDDS.LogPathFile = iconDDS.RelPathFile;
ImageArt.Add(iconDDS);
}
// Inlay Art
var inlayDDS = new GraphItemLLID();
inlayDDS.Canonical = CANONICAL_INLAY;
inlayDDS.RelPathDirectory = inlayDDS.Canonical;
inlayDDS.LogPathDirectory = inlayDDS.Canonical;
inlayDDS.Tag = new List<string>();
inlayDDS.Tag.Add(TagValue.DDS.GetDescription());
inlayDDS.Tag.Add(TagValue.Image.GetDescription());
inlayDDS.UUID = IdGenerator.Guid();
inlayDDS.LLID = Guid.Parse(IdGenerator.LLID());
inlayDDS.Name = String.Format("inlay_{0}", dlcName);
inlayDDS.RelPathFile = String.Format("{0}.dds", inlayDDS.Name);
inlayDDS.LogPathFile = inlayDDS.RelPathFile;
ImageArt.Add(inlayDDS);
// Inlay Nif
var nif = new GraphItemLLID();
nif.Canonical = CANONICAL_INLAY;
nif.RelPathDirectory = nif.Canonical;
nif.LogPathDirectory = nif.Canonical;
nif.Tag = new List<string>();
nif.Tag.Add(TagValue.Application.GetDescription());
nif.Tag.Add(TagValue.GamebryoSceneGraph.GetDescription());
nif.UUID = IdGenerator.Guid();
nif.LLID = Guid.Parse(IdGenerator.LLID());
nif.Name = dlcName;
nif.RelPathFile = String.Format("{0}.nif", dlcName);
nif.LogPathFile = nif.RelPathFile;
InlayNif = nif;
}
public void TestPackageGenerate()
{
var archivePaths = new List <string>();
foreach (var srcPath in TestSettings.Instance.ResourcePaths)
{
Debug.WriteLine("Processing: " + srcPath);
// load info from srcPath
DLCPackageData info = new DLCPackageData();
var platform = srcPath.GetPlatform();
if (platform.version == GameVersion.RS2012)
{
packageCreator.CurrentGameVersion = GameVersion.RS2012;
}
else
{
packageCreator.CurrentGameVersion = GameVersion.RS2014;
}
info = packageCreator.PackageImport(srcPath, TestSettings.Instance.TmpDestDir);
// set package version, old srcPackage may not have it
packageCreator.PackageVersion = "8"; // make easy to identify
packageCreator.AppId = "492988"; // free Bob Marley - Three Little Birds
// stress test package generation for all platforms
packageCreator.PlatformPC = true;
packageCreator.PlatformXBox360 = true;
packageCreator.PlatformPS3 = true;
packageCreator.PlatformMAC = true;
// skip testing ddc generation
// ConfigRepository.Instance()["ddc_autogen"] = "false";
if (packageCreator.CurrentGameVersion == GameVersion.RS2012)
{
packageCreator.AppId = "206102"; // free Holiday Song Pack
packageCreator.PlatformPS3 = false;
packageCreator.PlatformMAC = false;
}
// set destPath and test getting the package data
var archivePath = Path.Combine(TestSettings.Instance.TmpDestDir, Path.GetFileName(srcPath));
packageCreator.DestPath = archivePath;
var packageData = packageCreator.PackageGenerate();
Assert.NotNull(packageData);
// call background worker method from unit test to avoid threading issues
packageCreator.GeneratePackage(null, new DoWorkEventArgs(packageData));
var shortPath = archivePath.Replace("_p.psarc", "").Replace("_m.psarc", "").Replace("_ps3.psarc.edat", "").Replace("_xbox", "").Replace(".dat", "");
if (packageCreator.CurrentGameVersion == GameVersion.RS2012)
{
if (!File.Exists(shortPath + ".dat"))
{
Assert.Fail("RS1 PC Package Generation Failed ...");
}
if (!File.Exists(shortPath + "_xbox"))
{
Assert.Fail("RS1 Xbox Package Generation Failed ...");
}
}
else
{
if (!File.Exists(shortPath + "_p.psarc"))
{
Assert.Fail("PC Package Generation Failed ...");
}
if (!File.Exists(shortPath + "_m.psarc"))
{
Assert.Fail("Mac Package Generation Failed ...");
}
if (!File.Exists(shortPath + "_xbox"))
{
Assert.Fail("Xbox Package Generation Failed ...");
}
if (!File.Exists(shortPath + "_ps3.psarc.edat"))
{
Assert.Fail("PS3 Package Generation Failed ...");
}
// console files do not contain an AppId
if (!info.PS3 && !info.XBox360)
{
// check if GeneratePackage wrote the new AppId
using (var psarcLoader = new PsarcLoader(archivePath, true))
{
var entryAppId = psarcLoader.ExtractAppId();
Assert.AreEqual(packageCreator.AppId, entryAppId);
}
}
}
archivePaths.Add(archivePath);
}
Assert.AreEqual(TestSettings.Instance.ResourcePaths.Count, archivePaths.Count);
}
private void InlayAggregateGraph(DLCPackageData info, DLCPackageType dlcType)
{
var dlcName = info.Inlay.DLCSixName;
// Xblock
GameXblock = new List <GraphItem>();
var xbl = new GraphItem();
xbl.Name = String.Format("guitar_{0}", dlcName);
xbl.Canonical = String.Format(CANONICAL_XBLOCK[dlcType], dlcName);
xbl.RelPathDirectory = xbl.Canonical;
xbl.Tag = new List <string>();
xbl.Tag.Add(TagValue.EmergentWorld.GetDescription());
xbl.Tag.Add(TagValue.XWorld.GetDescription());
xbl.UUID = IdGenerator.Guid();
xbl.RelPathFile = String.Format("guitar_{0}.xblock", dlcName);
GameXblock.Add(xbl);
// JsonDB
JsonDB = new List <GraphItem>();
var json = new GraphItem();
json.Name = String.Format("dlc_guitar_{0}", dlcName);
json.Canonical = currentPlatform.IsConsole ? CANONICAL_MANIFEST_CONSOLE : 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("dlc_guitar_{0}.json", dlcName);
JsonDB.Add(json);
if (currentPlatform.IsConsole)
{
// HsonDB - One file for each manifest (Xbox360 / PS3 only)
HsonDB = new List <GraphItem>();
var hson = new GraphItem();
hson.Name = String.Format("dlc_{0}", dlcName);
hson.Canonical = CANONICAL_MANIFEST_CONSOLE;
hson.RelPathDirectory = hson.Canonical;
hson.Tag = new List <string>();
hson.Tag.Add(TagValue.Database.GetDescription());
hson.Tag.Add(TagValue.HsonDB.GetDescription());
hson.UUID = IdGenerator.Guid();
hson.RelPathFile = String.Format("dlc_{0}.hson", dlcName);
HsonDB.Add(hson);
}
else
{
// HsanDB - One file for all manifest (PC / Mac)
var hsan = new GraphItem();
hsan.Name = String.Format("dlc_{0}", dlcName);
hsan.Canonical = String.Format(CANONICAL_MANIFEST_PC, dlcName);
hsan.RelPathDirectory = hsan.Canonical;
hsan.Tag = new List <string>();
hsan.Tag.Add(TagValue.Database.GetDescription());
hsan.Tag.Add(TagValue.HsanDB.GetDescription());
hsan.UUID = IdGenerator.Guid();
hsan.RelPathFile = String.Format("dlc_{0}.hsan", dlcName);
HsanDB = hsan;
}
ImageArt = new List <GraphItemLLID>();
// Inlay Icon (DDS)
var aArtArray = new string[] { String.Format("reward_inlay_{0}_512", dlcName),
String.Format("reward_inlay_{0}_256", dlcName),
String.Format("reward_inlay_{0}_128", dlcName),
String.Format("reward_inlay_{0}_64", dlcName) };
foreach (var icon in aArtArray)
{
var iconDDS = new GraphItemLLID();
iconDDS.Canonical = CANONICAL_IMAGEART[dlcType];
iconDDS.RelPathDirectory = iconDDS.Canonical;
iconDDS.LogPathDirectory = iconDDS.Canonical;
iconDDS.Tag = new List <string>();
iconDDS.Tag.Add(TagValue.DDS.GetDescription());
iconDDS.Tag.Add(TagValue.Image.GetDescription());
iconDDS.UUID = IdGenerator.Guid();
iconDDS.LLID = IdGenerator.LLIDGuid();
iconDDS.Name = icon;
iconDDS.RelPathFile = String.Format("{0}.dds", iconDDS.Name);
iconDDS.LogPathFile = iconDDS.RelPathFile;
ImageArt.Add(iconDDS);
}
// Inlay Art
var inlayDDS = new GraphItemLLID();
inlayDDS.Canonical = CANONICAL_INLAY;
inlayDDS.RelPathDirectory = inlayDDS.Canonical;
inlayDDS.LogPathDirectory = inlayDDS.Canonical;
inlayDDS.Tag = new List <string>();
inlayDDS.Tag.Add(TagValue.DDS.GetDescription());
inlayDDS.Tag.Add(TagValue.Image.GetDescription());
inlayDDS.UUID = IdGenerator.Guid();
inlayDDS.LLID = IdGenerator.LLIDGuid();
inlayDDS.Name = String.Format("inlay_{0}", dlcName);
inlayDDS.RelPathFile = String.Format("{0}.dds", inlayDDS.Name);
inlayDDS.LogPathFile = inlayDDS.RelPathFile;
ImageArt.Add(inlayDDS);
// Inlay Nif
var nif = new GraphItemLLID();
nif.Canonical = CANONICAL_INLAY;
nif.RelPathDirectory = nif.Canonical;
nif.LogPathDirectory = nif.Canonical;
nif.Tag = new List <string>();
nif.Tag.Add(TagValue.Application.GetDescription());
nif.Tag.Add(TagValue.GamebryoSceneGraph.GetDescription());
nif.UUID = IdGenerator.Guid();
nif.LLID = IdGenerator.LLIDGuid();
nif.Name = dlcName;
nif.RelPathFile = String.Format("{0}.nif", dlcName);
nif.LogPathFile = nif.RelPathFile;
InlayNif = nif;
}
public AttributesHeader2014(string arrangementFileName, Arrangement arrangement, DLCPackageData info, Platform platform)
{
if (arrangement.ArrangementType == ArrangementType.ShowLight)
return;
IsVocal = arrangement.ArrangementType == Sng.ArrangementType.Vocal;
SongContent = (IsVocal) ? null : Song2014.LoadFromFile(arrangement.SongXml.File);
var dlcName = info.Name.ToLower();
var albumUrn = String.Format(URN_TEMPLATE, TagValue.Image.GetDescription(), TagValue.DDS.GetDescription(), String.Format("album_{0}", dlcName));
var jsonUrn = String.Format(URN_TEMPLATE, TagValue.Database.GetDescription(), TagValue.JsonDB.GetDescription(), String.Format("{0}_{1}", dlcName, arrangementFileName));
//FILL ATTRIBUTES
this.AlbumArt = albumUrn;
JapaneseVocal |= arrangement.Name == Sng.ArrangementName.JVocals;
ArrangementName = IsVocal ? Sng.ArrangementName.Vocals.ToString() : arrangement.Name.ToString(); //HACK: weird vocals stuff
DLC = true;
DLCKey = info.Name;
LeaderboardChallengeRating = 0;
ManifestUrn = jsonUrn;
MasterID_RDV = arrangement.MasterId;
PersistentID = arrangement.Id.ToString().Replace("-", "").ToUpper();
Shipping = true;
SKU = "RS2";
SongKey = info.Name;
if (!IsVocal)
{
AlbumName = AlbumNameSort = info.SongInfo.Album;
ArtistName = info.SongInfo.Artist;
CentOffset = (!arrangement.TuningPitch.Equals(0)) ? TuningFrequency.Frequency2Cents(arrangement.TuningPitch) : 0.0;
ArtistNameSort = info.SongInfo.ArtistSort;
CapoFret = (arrangement.Sng2014.Metadata.CapoFretId == 0xFF) ? CapoFret = 0 : Convert.ToDecimal(arrangement.Sng2014.Metadata.CapoFretId);
DNA_Chords = arrangement.Sng2014.DNACount[(int)DNAId.Chord];
DNA_Riffs = arrangement.Sng2014.DNACount[(int)DNAId.Riff];
DNA_Solo = arrangement.Sng2014.DNACount[(int)DNAId.Solo];
NotesEasy = arrangement.Sng2014.NoteCount[0];
NotesMedium = arrangement.Sng2014.NoteCount[1];
NotesHard = arrangement.Sng2014.NoteCount[2];
EasyMastery = NotesEasy / NotesHard;
MediumMastery = NotesMedium / NotesHard;
Metronome = (int?)arrangement.Metronome;
Representative = Convert.ToInt32(!arrangement.BonusArr);
RouteMask = (int)arrangement.RouteMask;
// TODO use ManifestFunctions.GetSongDifficulty() method (fix generation alghorythm)
SongDiffEasy = SongContent.SongLength / NotesEasy;
SongDiffMed = SongContent.SongLength / NotesMedium;
SongDiffHard = SongContent.SongLength / NotesHard;
SongDifficulty = SongDiffHard;
SongLength = (double?)Math.Round(SongContent.SongLength, 3, MidpointRounding.AwayFromZero);
SongName = info.SongInfo.SongDisplayName;
SongNameSort = info.SongInfo.SongDisplayNameSort;
SongYear = info.SongInfo.SongYear;
//Detect tuning
var tuning = TuningDefinitionRepository.Instance().SelectAny(SongContent.Tuning, platform.version);
if (tuning == null)
{
tuning = new TuningDefinition();
tuning.Tuning = SongContent.Tuning;
tuning.Name = tuning.UIName = arrangement.Tuning;
if (String.IsNullOrEmpty(tuning.Name))
{
tuning.Name = tuning.UIName = tuning.NameFromStrings(arrangement.TuningStrings, arrangement.ArrangementType == ArrangementType.Bass);
}
tuning.Custom = true;
tuning.GameVersion = GameVersion.RS2014;
TuningDefinitionRepository.Instance().Add(tuning, true);
}
Tuning = tuning.Tuning;
}
}
