private static void ConvertPackageForSimilarPlatform(string unpackedDir, string targetFileName, Platform sourcePlatform, Platform targetPlatform, string appId)
{
// Old and new paths
var sourceDir0 = sourcePlatform.GetPathName()[0].ToLower();
var sourceDir1 = sourcePlatform.GetPathName()[1].ToLower();
var targetDir0 = targetPlatform.GetPathName()[0].ToLower();
var targetDir1 = targetPlatform.GetPathName()[1].ToLower();
if (!targetPlatform.IsConsole)
{
// Replace AppId
var appIdFile = Path.Combine(unpackedDir, "appid.appid");
File.WriteAllText(appIdFile, appId);
}
// Replace aggregate graph values
var aggregateFile = Directory.EnumerateFiles(unpackedDir, "*.nt", SearchOption.AllDirectories).FirstOrDefault();
var aggregateGraphText = File.ReadAllText(aggregateFile);
// Tags
aggregateGraphText = Regex.Replace(aggregateGraphText, GraphItem.GetPlatformTagDescription(sourcePlatform.platform), GraphItem.GetPlatformTagDescription(targetPlatform.platform), RegexOptions.Multiline);
// Paths
aggregateGraphText = Regex.Replace(aggregateGraphText, sourceDir0, targetDir0, RegexOptions.Multiline);
aggregateGraphText = Regex.Replace(aggregateGraphText, sourceDir1, targetDir1, RegexOptions.Multiline);
File.WriteAllText(aggregateFile, aggregateGraphText);
// Rename directories
foreach (var dir in Directory.GetDirectories(unpackedDir, "*.*", SearchOption.AllDirectories))
{
if (dir.EndsWith(sourceDir0))
{
var newDir = dir.Substring(0, dir.LastIndexOf(sourceDir0)) + targetDir0;
DirectoryExtension.SafeDelete(newDir);
DirectoryExtension.Move(dir, newDir);
}
else if (dir.EndsWith(sourceDir1))
{
var newDir = dir.Substring(0, dir.LastIndexOf(sourceDir1)) + targetDir1;
DirectoryExtension.SafeDelete(newDir);
DirectoryExtension.Move(dir, newDir);
}
}
// Recreates SNG because SNG have different keys in PC and Mac
bool updateSNG = ((sourcePlatform.platform == GamePlatform.Pc && targetPlatform.platform == GamePlatform.Mac) || (sourcePlatform.platform == GamePlatform.Mac && targetPlatform.platform == GamePlatform.Pc));
// Packing
var dirToPack = unpackedDir;
if (sourcePlatform.platform == GamePlatform.XBox360)
dirToPack = Directory.GetDirectories(Path.Combine(unpackedDir, Packer.ROOT_XBox360))[0];
Packer.Pack(dirToPack, targetFileName, updateSNG, targetPlatform, fixShowlights: false);
DirectoryExtension.SafeDelete(unpackedDir);
}
public static string Convert(string sourcePackage, Platform sourcePlatform, Platform targetPlatform, string appId)
{
var needRebuildPackage = sourcePlatform.IsConsole != targetPlatform.IsConsole;
var tmpDir = Path.GetTempPath();
var fileName = Path.GetFileNameWithoutExtension(sourcePackage);
if (sourcePlatform.platform == GamePlatform.PS3)
if (fileName.Contains(".psarc"))
fileName = fileName.Substring(0, fileName.LastIndexOf("."));
var unpackedDir = Packer.Unpack(sourcePackage, tmpDir, false, true, false, sourcePlatform);
// DESTINATION
var nameTemplate = (!targetPlatform.IsConsole) ? "{0}{1}.psarc" : "{0}{1}";
var packageName = Path.GetFileNameWithoutExtension(sourcePackage);
if (packageName.EndsWith(new Platform(GamePlatform.Pc, GameVersion.None).GetPathName()[2]) ||
packageName.EndsWith(new Platform(GamePlatform.Mac, GameVersion.None).GetPathName()[2]) ||
packageName.EndsWith(new Platform(GamePlatform.XBox360, GameVersion.None).GetPathName()[2]) ||
packageName.EndsWith(new Platform(GamePlatform.PS3, GameVersion.None).GetPathName()[2] + ".psarc"))
{
packageName = packageName.Substring(0, packageName.LastIndexOf("_"));
}
var targetFileName = Path.Combine(Path.GetDirectoryName(sourcePackage), String.Format(nameTemplate, Path.Combine(Path.GetDirectoryName(sourcePackage), packageName), targetPlatform.GetPathName()[2]));
// CONVERSION
if (needRebuildPackage)
ConvertPackageRebuilding(unpackedDir, targetFileName, targetPlatform, appId);
else
ConvertPackageForSimilarPlatform(unpackedDir, targetFileName, sourcePlatform, targetPlatform, appId);
DirectoryExtension.SafeDelete(unpackedDir);
return String.Empty;
}
/// <summary>
/// Converts CDLC packages between platforms
/// </summary>
/// <param name="sourcePackage"></param>
/// <param name="sourcePlatform"></param>
/// <param name="targetPlatform"></param>
/// <param name="appId"></param>
/// <returns>Errors if any</returns>
public static string Convert(string sourcePackage, Platform sourcePlatform, Platform targetPlatform, string appId)
{
var needRebuildPackage = sourcePlatform.IsConsole != targetPlatform.IsConsole;
var tmpDir = Path.GetTempPath();
var unpackedDir = Packer.Unpack(sourcePackage, tmpDir, false, false, sourcePlatform);
// DESTINATION
var nameTemplate = (!targetPlatform.IsConsole) ? "{0}{1}.psarc" : "{0}{1}";
var packageName = Path.GetFileNameWithoutExtension(sourcePackage).StripPlatformEndName();
packageName = packageName.Replace(".","_");
var targetFileName = String.Format( nameTemplate, Path.Combine(Path.GetDirectoryName(sourcePackage), packageName), targetPlatform.GetPathName()[2] );
// CONVERSION
if (needRebuildPackage)
ConvertPackageRebuilding(unpackedDir, targetFileName, sourcePlatform, targetPlatform, appId);
else
ConvertPackageForSimilarPlatform(unpackedDir, targetFileName, sourcePlatform, targetPlatform, appId);
DirectoryExtension.SafeDelete(unpackedDir);
return String.Empty;
}
private static void UpdateSng2014(string songDirectory, Platform targetPlatform, bool fixShowlights = true)
{
var xmlFiles = Directory.EnumerateFiles(Path.Combine(songDirectory, "songs", "arr"), "*_*.xml", SearchOption.AllDirectories).ToList();
var sngFolder = Path.Combine(songDirectory, "songs", "bin", targetPlatform.GetPathName()[1].ToLower()); //-3 or more times re-calculation
foreach (var xmlFile in xmlFiles)
{
if (File.Exists(xmlFile))
{
var xmlName = Path.GetFileNameWithoutExtension(xmlFile);
bool noShowlights = true;
//Update Showlights
if (xmlName.ToLower().Contains("_showlights"))
UpdateShl(xmlFile, fixShowlights: fixShowlights);
else
{
var sngFile = Path.Combine(sngFolder, xmlName + ".sng");
var arrType = ArrangementType.Guitar;
if (Path.GetFileName(xmlFile).ToLower().Contains("vocal"))
arrType = ArrangementType.Vocal;
// Handle custom fonts
string fontSng = null;
if (arrType == ArrangementType.Vocal)
{
var vocSng = Sng2014File.LoadFromFile(sngFile, TryGetPlatformByEndName(songDirectory));
if (vocSng.IsCustomFont())
{
vocSng.WriteChartData((fontSng = Path.GetTempFileName()), new Platform(GamePlatform.Pc, GameVersion.None));
}
}
using (var fs = new FileStream(sngFile, FileMode.Create))
{
var sng = Sng2014File.ConvertXML(xmlFile, arrType, fontSng);
sng.WriteSng(fs, targetPlatform);
}
noShowlights &= !xmlFiles.Any(x => Path.GetFileName(x).Contains(xmlName.Split('_')[0].ToLower() + "_showlights"));
//Create Showlights
if (noShowlights && arrType != ArrangementType.Vocal)
{
var shlName = Path.Combine(Path.GetDirectoryName(xmlFile), xmlName.Split('_')[0] + "_showlights.xml");
var shl = new Showlight.Showlights(xmlFile);
if (shl.FixShowlights(shl))
{
using (var fs = new FileStream(shlName, FileMode.Create))
shl.Serialize(fs);
}
}
}
}
}
}
private static void UpdateSng(string songDirectory, Platform platform)
{
var xmlFiles = Directory.EnumerateFiles(Path.Combine(songDirectory, @"GR\Behaviors\Songs"));
foreach (var xmlFile in xmlFiles)
{
if (File.Exists(xmlFile) && Path.GetExtension(xmlFile) == ".xml")
{
var sngFile = Path.Combine(songDirectory, "GRExports", platform.GetPathName()[1], Path.GetFileNameWithoutExtension(xmlFile) + ".sng");
var arrType = ArrangementType.Guitar;
if (Path.GetFileName(xmlFile).ToLower().Contains("vocal"))
{
arrType = ArrangementType.Vocal;
SngFileWriter.Write(xmlFile, sngFile, arrType, platform);
}
else
{
Song song = Song.LoadFromFile(xmlFile);
if (!Enum.TryParse<ArrangementType>(song.Arrangement, out arrType))
if (song.Arrangement.ToLower().Contains("bass"))
arrType = ArrangementType.Bass;
}
SngFileWriter.Write(xmlFile, sngFile, arrType, platform);
}
else
{
throw new ArgumentException(String.Format("'{0}' is not a valid XML file.", xmlFile));
}
}
}
private static void GenerateSongPsarcRS1(Stream output, DLCPackageData info, Platform platform)
{
var soundBankName = String.Format("Song_{0}", info.Name);
try
{
Stream albumArtStream = null,
audioStream = null;
string albumArtPath;
if (File.Exists(info.AlbumArtPath)) {
albumArtPath = info.AlbumArtPath;
} else {
using (var defaultArtStream = new MemoryStream(Resources.albumart)) {
albumArtPath = GeneralExtensions.GetTempFileName(".dds");
defaultArtStream.WriteFile(albumArtPath);
defaultArtStream.Dispose();
TMPFILES_ART.Add(albumArtPath);
}
}
var ddsfiles = info.ArtFiles;
if (ddsfiles == null) {
ddsfiles = new List<DDSConvertedFile>();
ddsfiles.Add(new DDSConvertedFile() { sizeX = 512, sizeY = 512, sourceFile = albumArtPath, destinationFile = GeneralExtensions.GetTempFileName(".dds") });
ToDDS(ddsfiles);
// Save for reuse
info.ArtFiles = ddsfiles;
}
albumArtStream = new FileStream(ddsfiles[0].destinationFile, FileMode.Open, FileAccess.Read, FileShare.Read);
// AUDIO
var audioFile = info.OggPath;
if (File.Exists(audioFile))
if (platform.IsConsole != audioFile.GetAudioPlatform().IsConsole)
audioStream = OggFile.ConvertAudioPlatform(audioFile);
else
audioStream = File.OpenRead(audioFile);
else
throw new InvalidOperationException(String.Format("Audio file '{0}' not found.", audioFile));
using (var aggregateGraphStream = new MemoryStream())
using (var manifestStream = new MemoryStream())
using (var xblockStream = new MemoryStream())
using (var soundbankStream = new MemoryStream())
using (var packageIdStream = new MemoryStream())
using (var soundStream = OggFile.ConvertOgg(audioStream))
using (var arrangementFiles = new DisposableCollection<Stream>()) {
var manifestBuilder = new ManifestBuilder {
AggregateGraph = new AggregateGraph.AggregateGraph {
SoundBank = new SoundBank { File = soundBankName + ".bnk" },
AlbumArt = new AlbumArt { File = info.AlbumArtPath }
}
};
foreach (var x in info.Arrangements) {
//Generate sng file in execution time
GenerateSNG(x, platform);
manifestBuilder.AggregateGraph.SongFiles.Add(x.SongFile);
manifestBuilder.AggregateGraph.SongXMLs.Add(x.SongXml);
}
manifestBuilder.AggregateGraph.XBlock = new XBlockFile { File = info.Name + ".xblock" };
manifestBuilder.AggregateGraph.Write(info.Name, platform.GetPathName(), platform, aggregateGraphStream);
aggregateGraphStream.Flush();
aggregateGraphStream.Seek(0, SeekOrigin.Begin);
{
var manifestData = manifestBuilder.GenerateManifest(info.Name, info.Arrangements, info.SongInfo, platform);
var writer = new StreamWriter(manifestStream);
writer.Write(manifestData);
writer.Flush();
manifestStream.Seek(0, SeekOrigin.Begin);
}
GameXblock<Entity>.Generate(info.Name, manifestBuilder.Manifest, manifestBuilder.AggregateGraph, xblockStream);
xblockStream.Flush();
xblockStream.Seek(0, SeekOrigin.Begin);
var soundFileName = SoundBankGenerator.GenerateSoundBank(info.Name, soundStream, soundbankStream, info.Volume, platform);
soundbankStream.Flush();
soundbankStream.Seek(0, SeekOrigin.Begin);
GenerateSongPackageId(packageIdStream, info.Name);
var songPsarc = new PSARC.PSARC();
songPsarc.AddEntry("PACKAGE_ID", packageIdStream);
songPsarc.AddEntry("AggregateGraph.nt", aggregateGraphStream);
songPsarc.AddEntry("Manifests/songs.manifest.json", manifestStream);
songPsarc.AddEntry(String.Format("Exports/Songs/{0}.xblock", info.Name), xblockStream);
songPsarc.AddEntry(String.Format("Audio/{0}/{1}.bnk", platform.GetPathName()[0], soundBankName), soundbankStream);
songPsarc.AddEntry(String.Format("Audio/{0}/{1}.ogg", platform.GetPathName()[0], soundFileName), soundStream);
songPsarc.AddEntry(String.Format("GRAssets/AlbumArt/{0}.dds", manifestBuilder.AggregateGraph.AlbumArt.Name), albumArtStream);
foreach (var x in info.Arrangements) {
var xmlFile = File.OpenRead(x.SongXml.File);
arrangementFiles.Add(xmlFile);
var sngFile = File.OpenRead(x.SongFile.File);
arrangementFiles.Add(sngFile);
songPsarc.AddEntry(String.Format("GR/Behaviors/Songs/{0}.xml", Path.GetFileNameWithoutExtension(x.SongXml.File)), xmlFile);
songPsarc.AddEntry(String.Format("GRExports/{0}/{1}.sng", platform.GetPathName()[1], Path.GetFileNameWithoutExtension(x.SongFile.File)), sngFile);
}
songPsarc.Write(output, false);
output.Flush();
output.Seek(0, SeekOrigin.Begin);
}
}
finally
{
}
}
private static void GenerateRS2014SongPsarc(MemoryStream output, DLCPackageData info, Platform platform)
{
var dlcName = info.Name.ToLower();
{
var packPsarc = new PSARC.PSARC();
// Stream objects
Stream soundStream = null,
soundPreviewStream = null,
rsenumerableRootStream = null,
rsenumerableSongStream = null;
try {
// ALBUM ART
var ddsfiles = info.ArtFiles;
if (ddsfiles == null) {
string albumArtPath;
if (File.Exists(info.AlbumArtPath)) {
albumArtPath = info.AlbumArtPath;
} else {
using (var albumArtStream = new MemoryStream(Resources.albumart2014_256))
{
albumArtPath = GeneralExtensions.GetTempFileName(".dds");
albumArtStream.WriteFile(albumArtPath);
TMPFILES_ART.Add(albumArtPath);
}
}
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 DDS
ToDDS(ddsfiles);
// Save for reuse
info.ArtFiles = ddsfiles;
}
foreach (var dds in ddsfiles)
packPsarc.AddEntry(String.Format("gfxassets/album_art/album_{0}_{1}.dds", dlcName, dds.sizeX), new FileStream(dds.destinationFile, FileMode.Open, FileAccess.Read, FileShare.Read));
//Lyrics Font Texture
if (File.Exists(info.LyricsTex))
packPsarc.AddEntry(String.Format("assets/ui/lyrics/{0}/lyrics_{0}.dds", dlcName), new FileStream(info.LyricsTex, FileMode.Open, FileAccess.Read, FileShare.Read));
// AUDIO
var audioFile = info.OggPath;
if (File.Exists(audioFile))
if (platform.IsConsole != audioFile.GetAudioPlatform().IsConsole)
soundStream = OggFile.ConvertAudioPlatform(audioFile);
else
soundStream = File.OpenRead(audioFile);
else
throw new InvalidOperationException(String.Format("Audio file '{0}' not found.", audioFile));
// AUDIO PREVIEW
var previewAudioFile = info.OggPreviewPath;
if (File.Exists(previewAudioFile))
if (platform.IsConsole != previewAudioFile.GetAudioPlatform().IsConsole)
soundPreviewStream = OggFile.ConvertAudioPlatform(previewAudioFile);
else
soundPreviewStream = File.OpenRead(previewAudioFile);
else
soundPreviewStream = soundStream;
// FLAT MODEL
rsenumerableRootStream = new MemoryStream(Resources.rsenumerable_root);
packPsarc.AddEntry("flatmodels/rs/rsenumerable_root.flat", rsenumerableRootStream);
rsenumerableSongStream = new MemoryStream(Resources.rsenumerable_song);
packPsarc.AddEntry("flatmodels/rs/rsenumerable_song.flat", rsenumerableSongStream);
using (var toolkitVersionStream = new MemoryStream())
using (var appIdStream = new MemoryStream())
using (var packageListStream = new MemoryStream())
using (var soundbankStream = new MemoryStream())
using (var soundbankPreviewStream = new MemoryStream())
using (var aggregateGraphStream = new MemoryStream())
using (var manifestHeaderHSANStream = new MemoryStream())
using (var manifestHeaderHSONStreamList = new DisposableCollection<Stream>())
using (var manifestStreamList = new DisposableCollection<Stream>())
using (var arrangementStream = new DisposableCollection<Stream>())
using (var showlightStream = new MemoryStream())
using (var xblockStream = new MemoryStream())
{
// TOOLKIT VERSION
GenerateToolkitVersion(toolkitVersionStream, info.PackageVersion);
packPsarc.AddEntry("toolkit.version", toolkitVersionStream);
// APP ID
if (!platform.IsConsole)
{
GenerateAppId(appIdStream, info.AppId, platform);
packPsarc.AddEntry("appid.appid", appIdStream);
}
if (platform.platform == GamePlatform.XBox360) {
var packageListWriter = new StreamWriter(packageListStream);
packageListWriter.Write(dlcName);
packageListWriter.Flush();
packageListStream.Seek(0, SeekOrigin.Begin);
string packageList = "PackageList.txt";
packageListStream.WriteTmpFile(packageList, platform);
}
// SOUNDBANK
var soundbankFileName = String.Format("song_{0}", dlcName);
var audioFileNameId = SoundBankGenerator2014.GenerateSoundBank(info.Name, soundStream, soundbankStream, info.Volume, platform);
packPsarc.AddEntry(String.Format("audio/{0}/{1}.bnk", platform.GetPathName()[0].ToLower(), soundbankFileName), soundbankStream);
packPsarc.AddEntry(String.Format("audio/{0}/{1}.wem", platform.GetPathName()[0].ToLower(), audioFileNameId), soundStream);
// SOUNDBANK PREVIEW
var soundbankPreviewFileName = String.Format("song_{0}_preview", dlcName);
dynamic audioPreviewFileNameId;
var previewVolume = (info.PreviewVolume != null) ? (float)info.PreviewVolume : info.Volume;
if (!soundPreviewStream.Equals(soundStream))
audioPreviewFileNameId = SoundBankGenerator2014.GenerateSoundBank(info.Name + "_Preview", soundPreviewStream, soundbankPreviewStream, previewVolume, platform, true);
else
audioPreviewFileNameId = SoundBankGenerator2014.GenerateSoundBank(info.Name + "_Preview", soundPreviewStream, soundbankPreviewStream, info.Volume, platform, true, true);
packPsarc.AddEntry(String.Format("audio/{0}/{1}.bnk", platform.GetPathName()[0].ToLower(), soundbankPreviewFileName), soundbankPreviewStream);
if (!soundPreviewStream.Equals(soundStream)) packPsarc.AddEntry(String.Format("audio/{0}/{1}.wem", platform.GetPathName()[0].ToLower(), audioPreviewFileNameId), soundPreviewStream);
// AGGREGATE GRAPH
var aggregateGraphFileName = String.Format("{0}_aggregategraph.nt", dlcName);
var aggregateGraph = new AggregateGraph2014(info, platform);
aggregateGraph.Serialize(aggregateGraphStream);
aggregateGraphStream.Flush();
aggregateGraphStream.Seek(0, SeekOrigin.Begin);
packPsarc.AddEntry(aggregateGraphFileName, aggregateGraphStream);
var manifestHeader = new ManifestHeader2014<AttributesHeader2014>(platform);
var songPartition = new SongPartition();
var songPartitionCount = new SongPartition();
foreach (var arrangement in info.Arrangements)
{
var arrangementFileName = songPartition.GetArrangementFileName(arrangement.Name, arrangement.ArrangementType).ToLower();
// GAME SONG (SNG)
UpdateToneDescriptors(info);
GenerateSNG(arrangement, platform);
var sngSongFile = File.OpenRead(arrangement.SongFile.File);
arrangementStream.Add(sngSongFile);
packPsarc.AddEntry(String.Format("songs/bin/{0}/{1}_{2}.sng", platform.GetPathName()[1].ToLower(), dlcName, arrangementFileName), sngSongFile);
// XML SONG
var xmlSongFile = File.OpenRead(arrangement.SongXml.File);
arrangementStream.Add(xmlSongFile);
packPsarc.AddEntry(String.Format("songs/arr/{0}_{1}.xml", dlcName, arrangementFileName), xmlSongFile);
// MANIFEST
var manifest = new Manifest2014<Attributes2014>();
var attribute = new Attributes2014(arrangementFileName, arrangement, info, platform);
if (arrangement.ArrangementType != Sng.ArrangementType.Vocal)
{
attribute.SongPartition = songPartitionCount.GetSongPartition(arrangement.Name, arrangement.ArrangementType);
if (attribute.SongPartition > 1)
{ // Make the second arrangement with the same arrangement type as ALTERNATE arrangement ingame
attribute.Representative = 0;
attribute.ArrangementProperties.Represent = 0;
}
}
var attributeDictionary = new Dictionary<string, Attributes2014> { { "Attributes", attribute } };
manifest.Entries.Add(attribute.PersistentID, attributeDictionary);
var manifestStream = new MemoryStream();
manifestStreamList.Add(manifestStream);
manifest.Serialize(manifestStream);
manifestStream.Seek(0, SeekOrigin.Begin);
var jsonPathPC = "manifests/songs_dlc_{0}/{0}_{1}.json";
var jsonPathConsole = "manifests/songs_dlc/{0}_{1}.json";
packPsarc.AddEntry(String.Format((platform.IsConsole ? jsonPathConsole : jsonPathPC), dlcName, arrangementFileName), manifestStream);
// MANIFEST HEADER
var attributeHeaderDictionary = new Dictionary<string, AttributesHeader2014> { { "Attributes", new AttributesHeader2014(attribute) } };
if (platform.IsConsole) {
// One for each arrangements (Xbox360/PS3)
manifestHeader = new ManifestHeader2014<AttributesHeader2014>(platform);
manifestHeader.Entries.Add(attribute.PersistentID, attributeHeaderDictionary);
var manifestHeaderStream = new MemoryStream();
manifestHeaderHSONStreamList.Add(manifestHeaderStream);
manifestHeader.Serialize(manifestHeaderStream);
manifestStream.Seek(0, SeekOrigin.Begin);
packPsarc.AddEntry(String.Format("manifests/songs_dlc/{0}_{1}.hson", dlcName, arrangementFileName), manifestHeaderStream);
} else {
// One for all arrangements (PC/Mac)
manifestHeader.Entries.Add(attribute.PersistentID, attributeHeaderDictionary);
}
}
if (!platform.IsConsole) {
manifestHeader.Serialize(manifestHeaderHSANStream);
manifestHeaderHSANStream.Seek(0, SeekOrigin.Begin);
packPsarc.AddEntry(String.Format("manifests/songs_dlc_{0}/songs_dlc_{0}.hsan", dlcName), manifestHeaderHSANStream);
}
// SHOWLIGHT
Showlights showlight = new Showlights(info);
showlight.Serialize(showlightStream);
if(showlightStream.CanRead)
packPsarc.AddEntry(String.Format("songs/arr/{0}_showlights.xml", dlcName), showlightStream);
// XBLOCK
GameXblock<Entity2014> game = GameXblock<Entity2014>.Generate2014(info, platform);
game.SerializeXml(xblockStream);
xblockStream.Flush();
xblockStream.Seek(0, SeekOrigin.Begin);
packPsarc.AddEntry(String.Format("gamexblocks/nsongs/{0}.xblock", dlcName), xblockStream);
// WRITE PACKAGE
packPsarc.Write(output, !platform.IsConsole);
output.Flush();
output.Seek(0, SeekOrigin.Begin);
output.WriteTmpFile(String.Format("{0}.psarc", dlcName), platform);
}
} catch (Exception ex) {
throw ex;
} finally {
// Dispose all objects
if (soundStream != null)
soundStream.Dispose();
if (soundPreviewStream != null)
soundPreviewStream.Dispose();
if (rsenumerableRootStream != null)
rsenumerableRootStream.Dispose();
if (rsenumerableSongStream != null)
rsenumerableSongStream.Dispose();
DeleteTmpFiles(TMPFILES_SNG);
DeleteTmpFiles(TMPFILES_ART);
}
}
}
public static void Generate(string packagePath, DLCPackageData info, Platform platform, DLCPackageType dlcType = DLCPackageType.Song)
{
switch (platform.platform)
{
case GamePlatform.XBox360:
if (!Directory.Exists(XBOX_WORKDIR))
Directory.CreateDirectory(XBOX_WORKDIR);
break;
case GamePlatform.PS3:
if (!Directory.Exists(PS3_WORKDIR))
Directory.CreateDirectory(PS3_WORKDIR);
break;
}
using (var packPsarcStream = new MemoryStream())
{
switch (platform.version)
{
case GameVersion.RS2014:
switch (dlcType)
{
case DLCPackageType.Song:
GenerateRS2014SongPsarc(packPsarcStream, info, platform);
break;
case DLCPackageType.Lesson:
throw new NotImplementedException("Lesson package type not implemented yet :(");
case DLCPackageType.Inlay:
GenerateRS2014InlayPsarc(packPsarcStream, info, platform);
break;
}
break;
case GameVersion.RS2012:
GeneratePsarcsForRS1(packPsarcStream, info, platform);
break;
case GameVersion.None:
throw new InvalidOperationException("Unexpected game version value");
}
var packageName = Path.GetFileNameWithoutExtension(packagePath).StripPlatformEndName();
var songFileName = String.Format("{0}{1}", Path.Combine(Path.GetDirectoryName(packagePath), packageName), platform.GetPathName()[2]);
switch (platform.platform)
{
case GamePlatform.Pc:
case GamePlatform.Mac:
switch (platform.version)
{
// SAVE PACKAGE
case GameVersion.RS2014:
using (FileStream fl = File.Create(songFileName + ".psarc"))
packPsarcStream.CopyTo(fl);
break;
case GameVersion.RS2012:
using (var fl = File.Create(songFileName + ".dat"))
RijndaelEncryptor.EncryptFile(packPsarcStream, fl, RijndaelEncryptor.DLCKey);
break;
default:
throw new InvalidOperationException("Unexpected game version value");
}
break;
case GamePlatform.XBox360:
BuildXBox360Package(songFileName, info, FILES_XBOX, platform.version, dlcType);
break;
case GamePlatform.PS3:
EncryptPS3EdatFiles(songFileName + ".psarc", platform);
break;
}
}
FILES_XBOX.Clear();
FILES_PS3.Clear();
DeleteTmpFiles(TMPFILES_SNG);
}
private static void GenerateRS2014SongPsarc(Stream output, DLCPackageData info, Platform platform, int pnum = -1)
{
// TODO: Benchmark processes and optimize speed
dlcName = info.Name.ToLower();
packPsarc = new PSARC.PSARC();
// Stream objects
Stream soundStream = null,
soundPreviewStream = null,
rsenumerableRootStream = null,
rsenumerableSongStream = null;
try
{
// ALBUM ART
var ddsfiles = info.ArtFiles;
if (ddsfiles == null)
{
string albumArtPath;
if (File.Exists(info.AlbumArtPath))
{
albumArtPath = info.AlbumArtPath;
}
else
{
using (var albumArtStream = new MemoryStream(Resources.albumart2014_256))
{
albumArtPath = GeneralExtensions.GetTempFileName(".dds");
albumArtStream.WriteFile(albumArtPath);
TMPFILES_ART.Add(albumArtPath);
}
}
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 DDS
ToDDS(ddsfiles);
// Save for reuse
info.ArtFiles = ddsfiles;
}
foreach (var dds in info.ArtFiles)
{
packPsarc.AddEntry(String.Format("gfxassets/album_art/album_{0}_{1}.dds", dlcName, dds.sizeX), new FileStream(dds.destinationFile, FileMode.Open, FileAccess.Read, FileShare.Read));
TMPFILES_ART.Add(dds.destinationFile);
}
// Lyric Art Texture
if (File.Exists(info.LyricArtPath))
packPsarc.AddEntry(String.Format("assets/ui/lyrics/{0}/lyrics_{0}.dds", dlcName), new FileStream(info.LyricArtPath, FileMode.Open, FileAccess.Read, FileShare.Read));
// AUDIO
var audioFile = info.OggPath;
if (File.Exists(audioFile))
if (platform.IsConsole != audioFile.GetAudioPlatform().IsConsole)
soundStream = OggFile.ConvertAudioPlatform(audioFile);
else
soundStream = File.OpenRead(audioFile);
else
throw new InvalidOperationException(String.Format("Audio file '{0}' not found.", audioFile));
// AUDIO PREVIEW
var previewAudioFile = info.OggPreviewPath;
if (File.Exists(previewAudioFile))
if (platform.IsConsole != previewAudioFile.GetAudioPlatform().IsConsole)
soundPreviewStream = OggFile.ConvertAudioPlatform(previewAudioFile);
else
soundPreviewStream = File.OpenRead(previewAudioFile);
else
soundPreviewStream = soundStream;
// FLAT MODEL
rsenumerableRootStream = new MemoryStream(Resources.rsenumerable_root);
packPsarc.AddEntry("flatmodels/rs/rsenumerable_root.flat", rsenumerableRootStream);
rsenumerableSongStream = new MemoryStream(Resources.rsenumerable_song);
packPsarc.AddEntry("flatmodels/rs/rsenumerable_song.flat", rsenumerableSongStream);
using (var toolkitVersionStream = new MemoryStream())
using (var appIdStream = new MemoryStream())
using (var packageListStream = new MemoryStream())
using (var soundbankStream = new MemoryStream())
using (var soundbankPreviewStream = new MemoryStream())
using (var aggregateGraphStream = new MemoryStream())
using (var manifestHeaderHSANStream = new MemoryStream())
using (var manifestHeaderHSONStreamList = new DisposableCollection<Stream>())
using (var manifestStreamList = new DisposableCollection<Stream>())
using (var arrangementStream = new DisposableCollection<Stream>())
using (var showlightStream = new MemoryStream())
using (var xblockStream = new MemoryStream())
{
// TOOLKIT VERSION
var stopHere = info;
GenerateToolkitVersion(toolkitVersionStream, info.ToolkitInfo.PackageAuthor, info.ToolkitInfo.PackageVersion, info.ToolkitInfo.PackageComment);
packPsarc.AddEntry("toolkit.version", toolkitVersionStream);
// APP ID
if (!platform.IsConsole)
{
GenerateAppId(appIdStream, info.AppId, platform);
packPsarc.AddEntry("appid.appid", appIdStream);
}
if (platform.platform == GamePlatform.XBox360)
{
var packageListWriter = new StreamWriter(packageListStream);
packageListWriter.Write(dlcName);
packageListWriter.Flush();
packageListStream.Seek(0, SeekOrigin.Begin);
packageListStream.WriteTmpFile("PackageList.txt", platform);
}
// SOUNDBANK
var soundbankFileName = String.Format("song_{0}", dlcName);
var audioFileNameId = SoundBankGenerator2014.GenerateSoundBank(info.Name, soundStream, soundbankStream, info.Volume, platform);
packPsarc.AddEntry(String.Format("audio/{0}/{1}.bnk", platform.GetPathName()[0].ToLower(), soundbankFileName), soundbankStream);
packPsarc.AddEntry(String.Format("audio/{0}/{1}.wem", platform.GetPathName()[0].ToLower(), audioFileNameId), soundStream);
// SOUNDBANK PREVIEW
var soundbankPreviewFileName = String.Format("song_{0}_preview", dlcName);
dynamic audioPreviewFileNameId;
var previewVolume = info.PreviewVolume ?? info.Volume;
audioPreviewFileNameId = SoundBankGenerator2014.GenerateSoundBank(info.Name + "_Preview", soundPreviewStream, soundbankPreviewStream, previewVolume, platform, true, !(File.Exists(previewAudioFile)));
packPsarc.AddEntry(String.Format("audio/{0}/{1}.bnk", platform.GetPathName()[0].ToLower(), soundbankPreviewFileName), soundbankPreviewStream);
if (!soundPreviewStream.Equals(soundStream)) packPsarc.AddEntry(String.Format("audio/{0}/{1}.wem", platform.GetPathName()[0].ToLower(), audioPreviewFileNameId), soundPreviewStream);
// AGGREGATE GRAPH
var aggregateGraphFileName = String.Format("{0}_aggregategraph.nt", dlcName);
var aggregateGraph = new AggregateGraph2014.AggregateGraph2014(info, platform);
aggregateGraph.Serialize(aggregateGraphStream);
aggregateGraphStream.Flush();
aggregateGraphStream.Seek(0, SeekOrigin.Begin);
packPsarc.AddEntry(aggregateGraphFileName, aggregateGraphStream);
var manifestHeader = new ManifestHeader2014<AttributesHeader2014>(platform);
var songPartition = new SongPartition();
var songPartitionCount = new SongPartition();
foreach (var arrangement in info.Arrangements)
{
if (arrangement.ArrangementType == ArrangementType.ShowLight)
continue;
var arrangementFileName = songPartition.GetArrangementFileName(arrangement.Name, arrangement.ArrangementType).ToLower();
// GAME SONG (SNG)
UpdateToneDescriptors(info);
GenerateSNG(arrangement, platform);
var sngSongFile = File.OpenRead(arrangement.SongFile.File);
arrangementStream.Add(sngSongFile);
packPsarc.AddEntry(String.Format("songs/bin/{0}/{1}_{2}.sng", platform.GetPathName()[1].ToLower(), dlcName, arrangementFileName), sngSongFile);
// XML SONG
var xmlSongFile = File.OpenRead(arrangement.SongXml.File);
arrangementStream.Add(xmlSongFile);
packPsarc.AddEntry(String.Format("songs/arr/{0}_{1}.xml", dlcName, arrangementFileName), xmlSongFile);
// MANIFEST
var manifest = new Manifest2014<Attributes2014>();
var attribute = new Attributes2014(arrangementFileName, arrangement, info, platform);
if (arrangement.ArrangementType == ArrangementType.Bass || arrangement.ArrangementType == ArrangementType.Guitar)
{
// TODO: monitor this new code for bugs
// represent is set to "1" by default, if there is a bonus then set represent to "0"
attribute.Representative = arrangement.BonusArr ? 0 : 1;
attribute.ArrangementProperties.Represent = arrangement.BonusArr ? 0 : 1;
attribute.SongPartition = songPartitionCount.GetSongPartition(arrangement.Name, arrangement.ArrangementType);
if (attribute.SongPartition > 1 && !arrangement.BonusArr)
{
// for alternate arrangement then both represent and bonus are set to "0"
attribute.Representative = 0;
attribute.ArrangementProperties.Represent = 0;
}
}
var attributeDictionary = new Dictionary<string, Attributes2014> { { "Attributes", attribute } };
manifest.Entries.Add(attribute.PersistentID, attributeDictionary);
var manifestStream = new MemoryStream();
manifestStreamList.Add(manifestStream);
manifest.Serialize(manifestStream);
manifestStream.Seek(0, SeekOrigin.Begin);
const string jsonPathPC = "manifests/songs_dlc_{0}/{0}_{1}.json";
const string jsonPathConsole = "manifests/songs_dlc/{0}_{1}.json";
packPsarc.AddEntry(String.Format((platform.IsConsole ? jsonPathConsole : jsonPathPC), dlcName, arrangementFileName), manifestStream);
// MANIFEST HEADER
var attributeHeaderDictionary = new Dictionary<string, AttributesHeader2014> { { "Attributes", new AttributesHeader2014(attribute) } };
if (platform.IsConsole)
{
// One for each arrangements (Xbox360/PS3)
manifestHeader = new ManifestHeader2014<AttributesHeader2014>(platform);
manifestHeader.Entries.Add(attribute.PersistentID, attributeHeaderDictionary);
var manifestHeaderStream = new MemoryStream();
manifestHeaderHSONStreamList.Add(manifestHeaderStream);
manifestHeader.Serialize(manifestHeaderStream);
manifestStream.Seek(0, SeekOrigin.Begin);
packPsarc.AddEntry(String.Format("manifests/songs_dlc/{0}_{1}.hson", dlcName, arrangementFileName), manifestHeaderStream);
}
else
{
// One for all arrangements (PC/Mac)
manifestHeader.Entries.Add(attribute.PersistentID, attributeHeaderDictionary);
}
}
if (!platform.IsConsole)
{
manifestHeader.Serialize(manifestHeaderHSANStream);
manifestHeaderHSANStream.Seek(0, SeekOrigin.Begin);
packPsarc.AddEntry(String.Format("manifests/songs_dlc_{0}/songs_dlc_{0}.hsan", dlcName), manifestHeaderHSANStream);
}
// XML SHOWLIGHTS
var shlArr = info.Arrangements.FirstOrDefault(ar => ar.ArrangementType == ArrangementType.ShowLight);
if (shlArr != null && shlArr.SongXml.File != null)
using (var fs = File.OpenRead(shlArr.SongXml.File))
fs.CopyTo(showlightStream);
else
{
var showlight = new Showlights(info);
showlight.Serialize(showlightStream);
string shlFilePath = Path.Combine(Path.GetDirectoryName(info.Arrangements[0].SongXml.File), String.Format("{0}_showlights.xml", "cst"));
using (FileStream file = new FileStream(shlFilePath, FileMode.Create, FileAccess.Write))
showlightStream.WriteTo(file);
}
if (showlightStream.CanRead && showlightStream.Length > 0)
packPsarc.AddEntry(String.Format("songs/arr/{0}_showlights.xml", dlcName), showlightStream);
// XBLOCK
var game = GameXblock<Entity2014>.Generate2014(info, platform);
game.SerializeXml(xblockStream);
xblockStream.Flush();
xblockStream.Seek(0, SeekOrigin.Begin);
packPsarc.AddEntry(String.Format("gamexblocks/nsongs/{0}.xblock", dlcName), xblockStream);
// WRITE PACKAGE
packPsarc.Write(output, !platform.IsConsole);
output.WriteTmpFile(String.Format("{0}.psarc", dlcName), platform);
}
}
finally
{
// Dispose all objects
if (soundStream != null)
soundStream.Dispose();
if (soundPreviewStream != null)
soundPreviewStream.Dispose();
if (rsenumerableRootStream != null)
rsenumerableRootStream.Dispose();
if (rsenumerableSongStream != null)
rsenumerableSongStream.Dispose();
if (pnum <= 1)
DeleteTmpFiles(TMPFILES_ART);
DeleteTmpFiles(TMPFILES_SNG);
}
}
private static void UpdateSng2014(string songDirectory, Platform platform)
{
var xmlFiles = Directory.GetFiles(Path.Combine(songDirectory, "songs", "arr"), "*_*.xml", SearchOption.AllDirectories);
var sngFolder = Path.Combine(songDirectory, "songs", "bin", platform.GetPathName()[1]); //-3 or more times re-calculation
foreach (var xmlFile in xmlFiles)
{
if (File.Exists(xmlFile))
{
var xmlName = Path.GetFileNameWithoutExtension(xmlFile);
bool noShowlights = true;
//Update Showlights
if (xmlName.ToLower().Contains("_showlights"))
updateShl(xmlFile);
else
{
var sngFile = Path.Combine(sngFolder, xmlName + ".sng");
var arrType = ArrangementType.Guitar;
if (Path.GetFileName(xmlFile).ToLower().Contains("vocal"))
arrType = ArrangementType.Vocal;
using (FileStream fs = new FileStream(sngFile, FileMode.Create)) {
Sng2014File sng = Sng2014File.ConvertXML(xmlFile, arrType);
sng.WriteSng(fs, platform);
}
if (xmlFiles.Any(x => Path.GetFileName(x).Contains(xmlName.Split('_')[0].ToLower() + "_showlights")))
noShowlights = false;
//Create Showlights
if (noShowlights && arrType != ArrangementType.Vocal)
{
var shlName = Path.Combine(Path.GetDirectoryName(xmlFile), xmlName.Split('_')[0] + "_showlights.xml");
var shl = new RocksmithToolkitLib.DLCPackage.Showlight.Showlights();
if (shl.PopShList(shl.FixShowlights(shl.Genegate(xmlFile).ShowlightList)))
{
shl.Count = shl.ShowlightList.Count;
using (var fs = new FileStream(shlName, FileMode.Create))
shl.Serialize(fs);
noShowlights = false;
}
}
}
}
}
}