Program.cs

using System.Diagnostics;
using System.IO.Compression;
using TCCS.EndianUtils;
using TCCS.Handlers;
using static TCCS.Handlers.XWBHandler;

namespace TCCS
{
	class Program
	{
		public struct WBEntry
		{
			public string Name;
			public byte[]? Dpds;
			public byte[] Header, Data;
			public uint[]? Seek;
			public WaveFormat Format;
			public MetaData Metadata;

			internal WBEntry(WaveFormat EntryFormat, string EntryName, byte[] EntryHeader, MetaData EntryMeta, byte[] EntryData, byte[]? EntryDpds, uint[]? EntrySeek)
			{
				Format = EntryFormat;
				Name = EntryName;
				Header = EntryHeader;
				Metadata = EntryMeta;
				Data = EntryData;
				Dpds = EntryDpds;
				Seek = EntrySeek;
			}
		}

		private static readonly string[] CompressedTypes =
		[
			".xpr",
			".txt",
			".str",
			".ps",
			".vs",
			".xma",
			".xsb",
			".xgs",
			".xwb",
			".fnt"
		];

		internal static ushort BlockSetting { get; set; } = 128;
		public static WBEntry[] Entries { get; set; } = [];
		public static string[] SongNames { get; set; } = [];
		private static IEnumerable<(int index, T value)> Enumerate<T>(IEnumerable<T> Collection) => Collection.Select((Index, Value) => (Value, Index));

		private static void CopyDirectory(string SourcePath, string DestPath)
		{
			DirectoryInfo SourceInfo = new(SourcePath);
			Directory.CreateDirectory(DestPath);

			foreach (FileInfo TargetInfo in SourceInfo.GetFiles())
			{
				string TargetPath = Path.Combine(DestPath, TargetInfo.Name);
				TargetInfo.CopyTo(TargetPath);
			}

			DirectoryInfo[] Directories = SourceInfo.GetDirectories();
			foreach (DirectoryInfo Subs in Directories)
			{
				string NewDestPath = Path.Combine(DestPath, Subs.Name);
				CopyDirectory(Subs.FullName, NewDestPath);
			}
		}

		static void Main()
		{
			Console.WriteLine("Please ensure this tool is running in the same directory as Terraria's asset folder, which should be named 'Content', and the 'Prerequisites' folder.");
			Console.WriteLine("Press any key to continue:");
			Console.ReadKey();
			Console.Clear();
			Console.WriteLine("Please select what version this content folder is for:");
			Console.WriteLine("1) Initial Versions");
			Console.WriteLine("2) Version 1.01");
			Console.WriteLine("..or press any other key to exit.");
			Console.Write("\r\nType the number for which option you wish to select: ");

			byte VersionNum;
			switch (Console.ReadKey().Key)
			{
				case ConsoleKey.D1:
					VersionNum = 0;
					break;
				case ConsoleKey.D2:
					VersionNum = 1;
					break;
				default:
					return;
			}

			Console.Clear();

			for (int CheckIdx = 0; CheckIdx < 2; CheckIdx++)
			{
				string FolderName = (CheckIdx == 1) ? "Prerequisites" : "Content";
				Console.WriteLine("Now checking for the '" + FolderName + "' folder...");

				if (Directory.Exists(FolderName))
				{
					Console.WriteLine("Directory exists, proceeding...");
				}
				else
				{
					Console.WriteLine("Directory not found; Ensure this executable is placed in the same folder as the required folder.");
					return;
				}

				Thread.Sleep(1000);

				if (CheckIdx == 1)
				{
					Console.Clear();
				}
				else
				{
					Console.WriteLine();
				}
			}
			string ContentPath = Directory.GetCurrentDirectory() + @"\Content";
			string PrereqPath = Directory.GetCurrentDirectory() + @"\Prerequisites";
			string[] FileEntries = Directory.GetFiles(ContentPath, "*", SearchOption.AllDirectories);

			if (VersionNum == 0)
			{
				Console.WriteLine("For legal purposes, xDelta patches have been provided instead of source material. You will need xDelta v3.0.11 in the working directory of this suite.");
				Console.WriteLine("This is needed so that some original files can be transformed in to data that can be used with the decompilation.");
				Console.WriteLine("Type 'Y' once you have xDelta v3.0.11 in the same directory as this program and have named it 'xDelta3.exe':");
				ConsoleKeyInfo DeltaReady = Console.ReadKey();

				Console.WriteLine();

				if (DeltaReady.Key == ConsoleKey.Y)
				{
					if (File.Exists("xDelta3.exe"))
					{
						Console.WriteLine("Executable found; Proceeding...");
						Thread.Sleep(1000);
						Console.Clear();
					}
					else
					{
						Console.WriteLine("xDelta3 was not found in the current directory.");
						Console.WriteLine("You need xDelta3 in order to proceed.");
						return;
					}
				}
				else
				{
					Console.WriteLine("Input read failed, closing...");
					return;
				}

				if (!File.Exists(ContentPath + @"\SoundsOld.zip"))
				{
					ZipFile.CreateFromDirectory(ContentPath + @"\Sounds", ContentPath + @"\SoundsOld.zip");
				}
				Console.WriteLine("Patching...");
				Process Patcher = new();
				Patcher.StartInfo.FileName = "xDelta3.exe";
				Patcher.StartInfo.Arguments = string.Format("-d -s {0} {1} {2}", "\"" + ContentPath + @"\SoundsOld.zip" + "\"", "\"" + PrereqPath + @"\Patches\Sounds.pat" + "\"", "\"" + ContentPath + @"\SoundsNew.zip" + "\"");
				Patcher.StartInfo.UseShellExecute = false;
				Patcher.StartInfo.RedirectStandardOutput = true;
				Patcher.Start();
				Patcher.WaitForExit();

				Console.WriteLine("Extracting...");
				ZipFile.ExtractToDirectory(ContentPath + @"\SoundsNew.zip", ContentPath + @"\Sounds", true);
				Thread.Sleep(1000);
				File.Delete(ContentPath + @"\SoundsNew.zip");
				Console.WriteLine("Complete; proceeding...");
				Thread.Sleep(1000);
				Console.Clear();
			}

			if (VersionNum > 0)
			{
				Console.WriteLine("Content directories past the initial versions have compressed and encrypted data. This suite can handle them with the right tools.");
				Console.WriteLine("Does the content directory need decompression to get the raw assets?");
				Console.WriteLine("Type 'Y' if you require decompression to raw formats or 'N' if no decompression is needed:");
				ConsoleKeyInfo DontTouch = Console.ReadKey();

				Console.WriteLine();

				if (DontTouch.Key == ConsoleKey.N)
				{
					Console.WriteLine("Attempting to continue; Let's begin conversion...");
					Thread.Sleep(1000);
					Console.Clear();
				}
				else if (DontTouch.Key == ConsoleKey.Y)
				{
					if (File.Exists("xbdecompress.exe") && File.Exists("unbundler.exe") && File.Exists("xma2encode.exe") && File.Exists("xwmaencode.exe"))
					{
						Console.WriteLine("Required executables found; Let's begin conversion...");
						Thread.Sleep(1000);
						Console.Clear();

						for (int FileIdx = 0; FileIdx < FileEntries.Length; FileIdx++)
						{
							FileInfo CurrentFile = new(FileEntries[FileIdx]);

							if (CompressedTypes.Contains(CurrentFile.Extension))
							{
								Process Decompresser = new();
								Decompresser.StartInfo.FileName = "xbdecompress.exe";
								Decompresser.StartInfo.Arguments = string.Format("/Y {0} {1}", "\"" + CurrentFile.FullName + "\"", "\"" + CurrentFile.Directory + "\""); // We need the escaped quotes to support paths with spaces in them.
								Decompresser.StartInfo.UseShellExecute = false;
								Decompresser.StartInfo.RedirectStandardOutput = true;
								Decompresser.Start();
								Decompresser.WaitForExit();

								if (CurrentFile.Extension == ".xpr")
								{
									try
									{
										Process Unbundler = new();
										Unbundler.StartInfo.FileName = "unbundler.exe";
										Unbundler.StartInfo.Arguments = "\"" + CurrentFile.FullName + "\"";
										Unbundler.StartInfo.UseShellExecute = false;
										Unbundler.StartInfo.RedirectStandardOutput = true;
										Unbundler.Start();
										Unbundler.WaitForExit();

										string BasicName = Path.GetFileNameWithoutExtension(CurrentFile.FullName);
										string Output = CurrentFile.FullName[..^3] + "tga";

										File.Move(BasicName + ".tga", Output); // Unbundler does not allow for the output file to be sent to the source directory, so we need to move the .tga files from the .xpr files we have.
										File.Delete(CurrentFile.FullName);
									}
									catch (FileNotFoundException) // There exist a couple of files that seem to be bundled incorrectly, so Unbundler cannot unpack a .tga file (or any file), leading to an exception; we need to continue regardless.
									{
										continue;
									}
								}

								if (CurrentFile.Extension == ".xma")
								{
									string Output = CurrentFile.FullName[..^3] + "wav";
									Process Converter = new();
									Converter.StartInfo.FileName = "xma2encode.exe";
									Converter.StartInfo.Arguments = string.Format("{0} /DecodeToPCM {1}", "\"" + CurrentFile.FullName + "\"", "\"" + Output + "\"");
									Converter.StartInfo.UseShellExecute = false;
									Converter.StartInfo.RedirectStandardOutput = true;
									Converter.Start();
									Converter.WaitForExit();
									File.Delete(CurrentFile.FullName); // For the purpose of efficiency, I'm gonna delete every source file that can produce another one (e.g. no .xma if we got a .wav)
								}
							}
						}
					}
					else
					{
						Console.WriteLine("One of the following files is not found in the working directory:");
						Console.WriteLine("- xbdecompress.exe\n- unbundler.exe\n- xma2encode.exe\n- xwmaencode.exe");
						Console.WriteLine("Ensure these 4 files are placed in the same directory as this executable.");
						Console.WriteLine("You will also need the 3 decompressor dependencies: xbdm.dll, msvcp71.dll, and msvcr71.dll.");
						return;
					}
				}
				else
				{
					Console.WriteLine("Input read failed, closing...");
					return;
				}
			}

			Console.WriteLine("Checking for required music files...");

			DirectoryInfo RunDirectory = new(Environment.CurrentDirectory);
			string TotalDirectory = RunDirectory.FullName;
			byte Found = 0;
			for (int FileIdx = 0; FileIdx < FileEntries.Length; FileIdx++)
			{
				FileInfo CurrentFile = new(FileEntries[FileIdx]);
				string RelativePath = CurrentFile.FullName[(TotalDirectory.Length + 1)..];

				if (CurrentFile.Extension == ".xsb")
				{
					using var SoundsFile = new FileStream(RelativePath, FileMode.Open, FileAccess.Read);
					using var Reader = new XSBHandler(SoundsFile);
					SongNames = [.. Reader.Names]; // The soundbanks contain the WaveNames of each song.
					SoundsFile.Close();
					Found++;
				}

				if (CurrentFile.Extension == ".xwb")
				{
					using var MusicStream = new FileStream(RelativePath, FileMode.Open, FileAccess.Read);

					using (var Reader = new XWBHandler(MusicStream))
					{
						Entries = new WBEntry[Reader.Count];
						for (uint SongID = 0; SongID < Reader.Count; SongID++)
						{
							WaveFormat Format = Reader.GetWaveFormat(SongID);
							MemoryStream EntryHeaderStream = new();
							EndianWriter HeaderWriter = new(EntryHeaderStream, EndianWriter.Endianness.Little);

							HeaderWriter.Write((ushort)Format.Encoding);
							HeaderWriter.Write((ushort)Format.Channels);
							HeaderWriter.Write(Format.SampleRate);
							HeaderWriter.Write(Format.AvgBytesPerSecond);
							HeaderWriter.Write((ushort)Format.BlockAlignment);
							HeaderWriter.Write((ushort)Format.BitDepth);
							HeaderWriter.Write((ushort)Format.ExtraSize.Length);

							byte[] EntryArray = EntryHeaderStream.ToArray();
							byte[] EntryHeader = new byte[EntryArray.Length + Format.ExtraSize.Length];
							Buffer.BlockCopy(EntryArray, 0, EntryHeader, 0, EntryArray.Length);
							Buffer.BlockCopy(Format.ExtraSize, 0, EntryHeader, EntryArray.Length, Format.ExtraSize.Length);

							Entries[SongID].Header = EntryHeader;
							Entries[SongID].Format = Format;
							Entries[SongID].Name = Reader.GetName(SongID); // Unused here, but it remains for clarity.
							Entries[SongID].Metadata = Reader.GetMetadata(SongID);
							Entries[SongID].Dpds = Reader.GetDpds(SongID);

							uint[] Seeks = [];
							if (Entries[SongID].Format.Encoding >= EncodingType.WMAudio2 && Entries[SongID].Format.Encoding <= EncodingType.XMA2) // WMA2/3 & XMA1/2
							{
								Seeks = Reader.GetSeekTable(SongID);
							}
							Entries[SongID].Seek = Seeks;

							Entries[SongID].Data = Reader.GetWaveData(SongID);
						}
					}
					MusicStream.Close();
					Found++;
				}
			}

			if (Found == 2)
			{

				Console.WriteLine("What would you like the block alignment to be set at? (Default: 128)");
				Console.WriteLine("Please select your option below:");
				int MinBlock = 32;
				for (int i = 1; MinBlock <= 1024; i++, MinBlock *= 2)
				{
					Console.WriteLine($"{i}) {MinBlock}");
				}

				BlockSetting = (ushort)Console.ReadKey().Key;
				if (BlockSetting >= ((byte)ConsoleKey.D1) && ((byte)ConsoleKey.D6) <= 54)
				{
					BlockSetting -= (byte)ConsoleKey.D1; // For the below equation, we get a number between 0 and 5.
					BlockSetting = (ushort)Math.Pow(2, BlockSetting + 5); // Gets us 32, 64, 128, 256, 512, or 1024.
				}
				else
				{
					BlockSetting = 128;
				}

				Console.WriteLine();
				Console.WriteLine("Extracting music...");
				Directory.CreateDirectory(ContentPath + @"\ExtMusic");
				foreach (var (Index, Entry) in Enumerate(Entries))
				{
					WaveWriter WaveWriter = new(Entry.Format,
						Entry.Name,
						Entry.Header,
						Entry.Metadata,
						Entry.Data,
						Entry.Dpds,
						Entry.Seek,
						EndianReader.Endianness.Little);
					WaveWriter.Write(SongNames[Index], ContentPath + @"\ExtMusic");
				}
			}
			else
			{
				Console.WriteLine("Music files are either missing or in excess. Ensure only 1 .xwb and .xsb are present inside of the content directory.");
				return;
			}

			Console.WriteLine("Wave bank successfully split and converted to ADPCM Format.");
			Console.WriteLine("Press any key to continue:");
			Console.ReadKey();

			Console.Clear();

			Console.WriteLine("Moving stuff around...");
			Directory.Move(ContentPath + @"\Fonts", ContentPath + @"\FontsOld");
			CopyDirectory(PrereqPath + @"\Content\Fonts", ContentPath + @"\Fonts");
			CopyDirectory(PrereqPath + @"\Content\Achievements", ContentPath + @"\Achievements");
			CopyDirectory(PrereqPath + @"\Content\Images", ContentPath + @"\Images");
			CopyDirectory(PrereqPath + @"\Content\UI", ContentPath + @"\UI");
			File.Copy(PrereqPath + @"\Content\ACB.tga", ContentPath + @"\ACB.tga", true);
			File.Copy(PrereqPath + @"\Content\PEGI.xnb", ContentPath + @"\PEGI.xnb", true);
			File.Copy(PrereqPath + @"\Content\USK.xnb", ContentPath + @"\USK.xnb", true);
			Console.WriteLine();
			Console.WriteLine("Content folder setup completed successfully.");
			return;
		}
	}
}